Is score return from similarity_search_with_score in Weaviate is really cosine distance?
Labels: name: area: vector store, name: auto:question, name: auto:documentation

### System Info

langchain = 0.0.288
python = 3.8.0

### Who can help?

@hwchase17 
@eyurtsev

### Information

- [X] The official example notebooks/scripts
- [ ] My own modified scripts

### Related Components

- [ ] LLMs/Chat Models
- [ ] Embedding Models
- [ ] Prompts / Prompt Templates / Prompt Selectors
- [ ] Output Parsers
- [ ] Document Loaders
- [X] Vector Stores / Retrievers
- [ ] Memory
- [ ] Agents / Agent Executors
- [ ] Tools / Toolkits
- [ ] Chains
- [ ] Callbacks/Tracing
- [ ] Async

### Reproduction

I'm sorry, I'm not very familiar with this field, 
but I don't quite understand how the description of this function differs from its actual operation.
```
    def similarity_search_with_score(
        self, query: str, k: int = 4, **kwargs: Any
    ) -> List[Tuple[Document, float]]:
        """
        Return list of documents most similar to the query
        text and cosine distance in float for each.
        Lower score represents more similarity.
        """
        if self._embedding is None:
            raise ValueError(
                "_embedding cannot be None for similarity_search_with_score"
            )
        content: Dict[str, Any] = {"concepts": [query]}
        if kwargs.get("search_distance"):
            content["certainty"] = kwargs.get("search_distance")
        query_obj = self._client.query.get(self._index_name, self._query_attrs)
        if kwargs.get("where_filter"):
            query_obj = query_obj.with_where(kwargs.get("where_filter"))

        embedded_query = self._embedding.embed_query(query)
        if not self._by_text:
            vector = {"vector": embedded_query}
            result = (
                query_obj.with_near_vector(vector)
                .with_limit(k)
                .with_additional("vector")
                .do()
            )
        else:
            result = (
                query_obj.with_near_text(content)
                .with_limit(k)
                .with_additional("vector")
                .do()
            )

        if "errors" in result:
            raise ValueError(f"Error during query: {result['errors']}")

        docs_and_scores = []
        for res in result["data"]["Get"][self._index_name]:
            text = res.pop(self._text_key)
            score = np.dot(res["_additional"]["vector"], embedded_query)
            docs_and_scores.append((Document(page_content=text, metadata=res), score))
        return docs_and_scores
```

### Expected behavior

`score = np.dot(res["_additional"]["vector"], embedded_query)`
As you can see, the description mentions that the `score` corresponds to `cosine distance`, but the `code` seems to only calculate the `dot product`. Am I missing something?

And Here is some definition from Weaviate:
[https://weaviate.io/blog/distance-metrics-in-vector-search#cosine-similarity](url)
![image](https://github.com/langchain-ai/langchain/assets/96753147/bee3b733-6bb5-4a9e-80f6-aa9179659393)


Thanks for your kind help!