> ## Documentation Index
> Fetch the complete documentation index at: https://langchat.neurobrains.co/llms.txt
> Use this file to discover all available pages before exploring further.

# Extending Adapters

> Build custom LLM, vector database, or reranker adapters for LangChat.

## When to extend

The built-in providers cover the most common cases. Build a custom adapter when you need:

* A different LLM not yet supported (e.g., a private model, Azure OpenAI)
* A different vector database (e.g., Weaviate, Qdrant, Chroma)
* A different reranker
* Custom pre/post processing in any adapter layer

***

## Custom LLM provider

LangChat's engine expects an LLM that implements `invoke()` and `ainvoke()` methods returning an object with a `.content` attribute.

```python theme={null}
from langchat.adapters.llm._base_llm import BaseLLM, AIMessage
from typing import Any

def my_model_call(messages: list[Any]) -> str:
    """Call your model and return the response text."""
    # Extract the last user message
    last_message = messages[-1].content if hasattr(messages[-1], "content") else str(messages[-1])

    # Call your custom model here
    response = my_custom_api.generate(last_message)
    return response.text

# Wrap in BaseLLM
llm = BaseLLM(invoke_func=my_model_call)

# Use like any other provider
from langchat import LangChat
from langchat.providers import Pinecone, Supabase

lc = LangChat(
    llm=llm,
    vector_db=Pinecone("my-index"),
    db=Supabase(),
)
```

### Azure OpenAI example

```python theme={null}
from openai import AzureOpenAI
from langchat.adapters.llm._base_llm import BaseLLM

azure_client = AzureOpenAI(
    api_key=os.environ["AZURE_OPENAI_KEY"],
    api_version="2024-02-01",
    azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
)

def azure_call(messages: list) -> str:
    formatted = [{"role": "user", "content": m.content} for m in messages]
    response = azure_client.chat.completions.create(
        model="gpt-4o",
        messages=formatted,
    )
    return response.choices[0].message.content

llm = BaseLLM(invoke_func=azure_call)
```

***

## Custom vector database

LangChat's engine calls `vector_adapter.get_retriever()` to get a LangChain retriever. Any LangChain-compatible vector store retriever works.

```python theme={null}
import os
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings

class ChromaAdapter:
    """Custom Chroma vector database adapter."""

    def __init__(self, collection_name: str, persist_dir: str = "./chroma_db"):
        self.embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
        self.store = Chroma(
            collection_name=collection_name,
            embedding_function=self.embeddings,
            persist_directory=persist_dir,
        )

    def get_retriever(self, k: int = 5):
        return self.store.as_retriever(search_kwargs={"k": k})

# Use with LangChat
from langchat import LangChat
from langchat.providers import OpenAI, Supabase

lc = LangChat(
    llm=OpenAI("gpt-4o-mini"),
    vector_db=ChromaAdapter("my-collection"),
    db=Supabase(),
)
```

***

## Custom database adapter

LangChat calls `db.client` to get the Supabase client. For a different database backend, implement the same interface.

```python theme={null}
class MockDatabaseAdapter:
    """In-memory database adapter for testing."""

    def __init__(self):
        self._data = {}

    @property
    def client(self):
        return self  # return self as the "client"

    def table(self, name: str):
        return self

    def insert(self, data: dict):
        return self

    def select(self, cols: str = "*"):
        return self

    def eq(self, col: str, val):
        return self

    def execute(self):
        class Result:
            data = []
        return Result()
```

***

## Contributing a new provider

If your adapter could benefit other users, consider contributing it to LangChat:

1. Add the adapter in `src/langchat/adapters/<category>/`
2. Add the provider wrapper in `src/langchat/providers/__init__.py`
3. Add tests in `tests/adapters/<category>/`
4. Update the documentation in `docs/adapters/`
5. Open a PR on [GitHub](https://github.com/neurobrains/langchat)

See [CONTRIBUTING.md](https://github.com/neurobrains/langchat/blob/develop/CONTRIBUTING.md) for the full contribution guide.