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

# LangChain

> Use Memvid as a retriever in LangChain applications

Integrate Memvid with LangChain to build powerful RAG pipelines. The `langchain` adapter provides native LangChain tools for seamless integration with agents.

<Tabs>
  <Tab title="Node.js">
    ## Installation

    ```bash theme={null}
    npm install @memvid/sdk @langchain/core @langchain/openai @langchain/langgraph zod
    ```

    ## Quick Start

    ```typescript theme={null}
    import { use } from '@memvid/sdk';

    // Open with LangChain adapter
    const mem = await use('langchain', 'knowledge.mv2');

    // Access LangChain tools (compatible with createReactAgent)
    const tools = mem.tools;  // Array of tool() objects
    ```
  </Tab>

  <Tab title="Python">
    ## Installation

    ```bash theme={null}
    pip install memvid-sdk langchain langchain-openai
    ```

    ## Quick Start

    ```python theme={null}
    from memvid_sdk import create, use
    import os

    # Create new file or open existing
    if os.path.exists('knowledge.mv2'):
        mem = use('langchain', 'knowledge.mv2')
    else:
        mem = create('knowledge.mv2', kind='langchain')

    # Access LangChain tools
    tools = mem.tools  # Returns LangChain StructuredTool objects
    ```
  </Tab>
</Tabs>

## Using Tools with Agents

<Tabs>
  <Tab title="Node.js">
    ```typescript theme={null}
    import { use } from '@memvid/sdk';
    import { ChatOpenAI } from '@langchain/openai';
    import { createReactAgent } from '@langchain/langgraph/prebuilt';
    import { HumanMessage } from '@langchain/core/messages';

    // Get Memvid tools
    const mem = await use('langchain', 'knowledge.mv2');
    const tools = mem.tools;

    // Create agent with LangGraph
    const llm = new ChatOpenAI({ model: 'gpt-4o' });
    const agent = createReactAgent({ llm, tools });

    // Run
    const inputs = { messages: [new HumanMessage('Search for authentication info')] };
    const stream = await agent.stream(inputs, { streamMode: 'values' });

    for await (const { messages } of stream) {
      const lastMsg = messages[messages.length - 1];
      if (lastMsg.content) {
        console.log(lastMsg.content);
      }
    }
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={null}
    from memvid_sdk import create, use
    from langchain_openai import ChatOpenAI
    from langgraph.prebuilt import create_react_agent
    import os

    # Create new file or open existing
    if os.path.exists('knowledge.mv2'):
        mem = use('langchain', 'knowledge.mv2')
    else:
        mem = create('knowledge.mv2', kind='langchain')

    tools = mem.tools

    # Create agent with LangGraph
    llm = ChatOpenAI(model="gpt-4o")
    agent = create_react_agent(llm, tools)

    # Run
    inputs = {"messages": [("user", "Search for information about authentication")]}
    result = agent.invoke(inputs)
    print(result["messages"][-1].content)
    ```
  </Tab>
</Tabs>

## Available Tools

The LangChain adapter provides three tools:

| Tool          | Description                                           |
| ------------- | ----------------------------------------------------- |
| `memvid_put`  | Store documents in memory with title, label, and text |
| `memvid_find` | Search for relevant documents by query                |
| `memvid_ask`  | Ask questions with RAG-style answer synthesis         |

## Using as a Retriever (Python)

```python theme={null}
from memvid_sdk import use
from langchain_openai import ChatOpenAI
from langchain.chains import RetrievalQA

# Initialize with langchain adapter
mem = use('langchain', 'knowledge.mv2', read_only=True)

# Get the retriever
retriever = mem.as_retriever(k=5)

# Create QA chain
qa_chain = RetrievalQA.from_chain_type(
    llm=ChatOpenAI(model="gpt-4o"),
    retriever=retriever
)

result = qa_chain.run("What is the main concept?")
print(result)
```

## Conversational RAG (Python)

```python theme={null}
from memvid_sdk import use
from langchain_openai import ChatOpenAI
from langchain.chains import ConversationalRetrievalChain
from langchain.memory import ConversationBufferMemory

# Initialize
mem = use('langchain', 'knowledge.mv2', read_only=True)
retriever = mem.as_retriever(k=5)

# Create conversational chain
llm = ChatOpenAI(model="gpt-4o")
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)

chain = ConversationalRetrievalChain.from_llm(
    llm=llm,
    retriever=retriever,
    memory=memory
)

# Chat
response = chain.invoke({"question": "What are the key features?"})
print(response["answer"])

# Follow up
response = chain.invoke({"question": "Tell me more about that"})
print(response["answer"])
```

## Custom Search Options

```python theme={null}
from memvid_sdk import use

mem = use('langchain', 'knowledge.mv2')

# Search with specific mode
results = mem.find('authentication', mode='lex', k=10)  # Lexical only
results = mem.find('user login flow', mode='sem', k=10)  # Semantic only
results = mem.find('auth best practices', mode='auto', k=10)  # Hybrid

# With scope filtering
results = mem.find('API', scope='mv2://docs/', k=5)
```

## Best Practices

1. **Use read-only mode** for retrieval-only applications
2. **Set appropriate k values** based on your context window
3. **Use hybrid mode** for best recall
4. **Close the memory** when done

```python theme={null}
mem = use('langchain', 'knowledge.mv2', read_only=True)
try:
    # Do work
    results = mem.find('query', k=10)
finally:
    mem.seal()
```

## Next Steps

<CardGroup cols={2}>
  <Card title="LlamaIndex" icon="database" href="/frameworks/llamaindex">
    LlamaIndex integration
  </Card>

  <Card title="Python SDK" icon="python" href="/python-sdk/overview">
    Full Python SDK documentation
  </Card>
</CardGroup>