couchbase: Add standard and semantic caches (#23607)

Thank you for contributing to LangChain!

**Description:** Add support for caching (standard + semantic) LLM
responses using Couchbase


- [x] **Add tests and docs**: If you're adding a new integration, please
include
1. a test for the integration, preferably unit tests that do not rely on
network access,
2. an example notebook showing its use. It lives in
`docs/docs/integrations` directory.


- [x] **Lint and test**: Run `make format`, `make lint` and `make test`
from the root of the package(s) you've modified. See contribution
guidelines for more: https://python.langchain.com/docs/contributing/

Additional guidelines:
- Make sure optional dependencies are imported within a function.
- Please do not add dependencies to pyproject.toml files (even optional
ones) unless they are required for unit tests.
- Most PRs should not touch more than one package.
- Changes should be backwards compatible.
- If you are adding something to community, do not re-import it in
langchain.

If no one reviews your PR within a few days, please @-mention one of
baskaryan, efriis, eyurtsev, ccurme, vbarda, hwchase17.

---------

Co-authored-by: Nithish Raghunandanan <nithishr@users.noreply.github.com>
Co-authored-by: Erick Friis <erick@langchain.dev>

libs/partners/couchbase/tests/utils.py

@@ -1,10 +1,11 @@
 """Fake Embedding class for testing purposes."""
 
-from typing import List
+from typing import Any, Dict, List, Mapping, Optional, cast
 
+from langchain_core.callbacks import CallbackManagerForLLMRun
 from langchain_core.embeddings import Embeddings
-
-fake_texts = ["foo", "bar", "baz"]
+from langchain_core.language_models.llms import LLM
+from langchain_core.pydantic_v1 import validator
 
 
 class FakeEmbeddings(Embeddings):
@@ -53,3 +54,57 @@ class ConsistentFakeEmbeddings(FakeEmbeddings):
         """Return consistent embeddings for the text, if seen before, or a constant
         one if the text is unknown."""
         return self.embed_documents([text])[0]
+
+
+class FakeLLM(LLM):
+    """Fake LLM wrapper for testing purposes."""
+
+    queries: Optional[Mapping] = None
+    sequential_responses: Optional[bool] = False
+    response_index: int = 0
+
+    @validator("queries", always=True)
+    def check_queries_required(
+        cls, queries: Optional[Mapping], values: Mapping[str, Any]
+    ) -> Optional[Mapping]:
+        if values.get("sequential_response") and not queries:
+            raise ValueError(
+                "queries is required when sequential_response is set to True"
+            )
+        return queries
+
+    def get_num_tokens(self, text: str) -> int:
+        """Return number of tokens."""
+        return len(text.split())
+
+    @property
+    def _llm_type(self) -> str:
+        """Return type of llm."""
+        return "fake"
+
+    def _call(
+        self,
+        prompt: str,
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> str:
+        if self.sequential_responses:
+            return self._get_next_response_in_sequence
+        if self.queries is not None:
+            return self.queries[prompt]
+        if stop is None:
+            return "foo"
+        else:
+            return "bar"
+
+    @property
+    def _identifying_params(self) -> Dict[str, Any]:
+        return {}
+
+    @property
+    def _get_next_response_in_sequence(self) -> str:
+        queries = cast(Mapping, self.queries)
+        response = queries[list(queries.keys())[self.response_index]]
+        self.response_index = self.response_index + 1
+        return response