LangChain

https://docs.langchain.com/oss/python/langchain/
Admin
LangChain is an open-source framework with a pre-built agent architecture and integrations for...
Tokens:240,907
Snippets:1,678
Trust Score:10
Update:1 week ago
Show doc for...
Tokens:
Raw
### Install and initialize PineconeVectorStore

Source: https://docs.langchain.com/oss/python/langchain/knowledge-base

Installs langchain-pinecone and connects PineconeVectorStore to an existing index.

```bash
pip install -qU langchain-pinecone

```

```python
from langchain_pinecone import PineconeVectorStore
from pinecone import Pinecone

pc = Pinecone(api_key=...)
index = pc.Index(index_name)

vector_store = PineconeVectorStore(embedding=embeddings, index=index)

```

--------------------------------

### Run an agent with automatic LangSmith tracing

Source: https://docs.langchain.com/oss/python/langchain/observability

Example agent setup using create_agent with custom tools and system prompt. By default, traces are logged to the 'default' project; configure a custom project name as described in the 'Log to a project' section.

```python
from langchain.agents import create_agent


def send_email(to: str, subject: str, body: str):
    """Send an email to a recipient."""
    # ... email sending logic
    return f"Email sent to {to}"

def search_web(query: str):
    """Search the web for information."""
    # ... web search logic
    return f"Search results for: {query}"

agent = create_agent(
    model="gpt-5.5",
    tools=[send_email, search_web],
    system_prompt="You are a helpful assistant that can send emails and search the web."
)

# Run the agent - all steps will be traced automatically
response = agent.invoke({
    "messages": [{"role": "user", "content": "Search for the latest AI news and email a summary to john@example.com"}]
})
```

--------------------------------

### Start the CopilotKit runtime with bun

Source: https://docs.langchain.com/oss/python/langchain/frontend/integrations/copilotkit

Run this command to start the Node.js CopilotKit runtime server. It should be started next to the LangGraph deployment.

```bash
bun server.ts
```

--------------------------------

### Create SkillMiddleware and SQL assistant agent with create_agent

Source: https://docs.langchain.com/oss/python/langchain/multi-agent/skills-sql-assistant

Complete example of a SQL assistant agent using LangGraph's AgentMiddleware and create_agent. It defines SkillMiddleware to inject skill descriptions into the system prompt, registers the load_skill tool, initializes a ChatOpenAI model, and demonstrates invoking the agent with a user request. Requires installing langchain, langchain-openai, and langgraph, and setting an API key.

```python
class SkillMiddleware(AgentMiddleware):
    """Middleware that injects skill descriptions into the system prompt."""

    # Register the load_skill tool as a class variable
    tools = [load_skill]

    def __init__(self):
        """Initialize and generate the skills prompt from SKILLS."""
        # Build skills prompt from the SKILLS list
        skills_list = []
        for skill in SKILLS:
            skills_list.append(
                f"- **{skill['name']}**: {skill['description']}"
            )
        self.skills_prompt = "\n".join(skills_list)

    def wrap_model_call(
        self,
        request: ModelRequest,
        handler: Callable[[ModelRequest], ModelResponse],
    ) -> ModelResponse:
        """Sync: Inject skill descriptions into system prompt."""
        # Build the skills addendum
        skills_addendum = (
            f"\n\n## Available Skills\n\n{self.skills_prompt}\n\n"
            "Use the load_skill tool when you need detailed information "
            "about handling a specific type of request."
        )

        # Append to system message content blocks
        new_content = list(request.system_message.content_blocks) + [
            {"type": "text", "text": skills_addendum}
        ]
        new_system_message = SystemMessage(content=new_content)
        modified_request = request.override(system_message=new_system_message)
        return handler(modified_request)

# Initialize your chat model (replace with your model)
# Example: from langchain_anthropic import ChatAnthropic
# model = ChatAnthropic(model="claude-3-5-sonnet-20241022")
from langchain_openai import ChatOpenAI
model = ChatOpenAI(model="gpt-5.5")

# Create the agent with skill support
agent = create_agent(
    model,
    system_prompt=(
        "You are a SQL query assistant that helps users "
        "write queries against business databases."
    ),
    middleware=[SkillMiddleware()],
    checkpointer=InMemorySaver(),
)

# Example usage
if __name__ == "__main__":
    # Configuration for this conversation thread
    thread_id = str(uuid7())
    config = {"configurable": {"thread_id": thread_id}}

    # Ask for a SQL query
    result = agent.invoke(
        {
            "messages": [
                {
                    "role": "user",
                    "content": (
                        "Write a SQL query to find all customers "
                        "who made orders over $1000 in the last month"
                    ),
                }
            ]
        },
        config
    )

    # Print the conversation
    for message in result["messages"]:
        if hasattr(message, 'pretty_print'):
            message.pretty_print()
        else:
            print(f"{message.type}: {message.content}")

```

--------------------------------

### Install and configure QdrantVectorStore

Source: https://docs.langchain.com/oss/python/langchain/knowledge-base

Installs langchain-qdrant and initializes QdrantVectorStore with an in-memory client and custom collection.

```bash
pip install -qU langchain-qdrant

```

```python
from qdrant_client.models import Distance, VectorParams
from langchain_qdrant import QdrantVectorStore
from qdrant_client import QdrantClient

client = QdrantClient(":memory:")

vector_size = len(embeddings.embed_query("sample text"))

if not client.collection_exists("test"):
    client.create_collection(
        collection_name="test",
        vectors_config=VectorParams(size=vector_size, distance=Distance.COSINE)
    )
vector_store = QdrantVectorStore(
    client=client,
    collection_name="test",
    embedding=embeddings,
)

```

--------------------------------

### Install and initialize Isaacus embeddings

Source: https://docs.langchain.com/oss/python/langchain/knowledge-base

Install langchain-isaacus and set up IsaacusEmbeddings with kanon-2-embedder.

```bash
pip install -qU langchain-isaacus

```

```python
import getpass
import os

if not os.environ.get("ISAACUS_API_KEY"):
os.environ["ISAACUS_API_KEY"] = getpass.getpass("Enter API key for Isaacus: ")

from langchain_isaacus import IsaacusEmbeddings

embeddings = IsaacusEmbeddings(model="kanon-2-embedder")

```

--------------------------------

### Install and initialize NVIDIA embeddings

Source: https://docs.langchain.com/oss/python/langchain/knowledge-base

Install langchain-nvidia-ai-endpoints and initialize NVIDIAEmbeddings with NV-Embed-QA.

```bash
pip install -qU langchain-nvidia-ai-endpoints

```

```python
import getpass
import os

if not os.environ.get("NVIDIA_API_KEY"):
    os.environ["NVIDIA_API_KEY"] = getpass.getpass("Enter API key for NVIDIA: ")

from langchain_nvidia_ai_endpoints import NVIDIAEmbeddings

embeddings = NVIDIAEmbeddings(model="NV-Embed-QA")

```

--------------------------------

### Install and initialize HuggingFace embeddings

Source: https://docs.langchain.com/oss/python/langchain/knowledge-base

Install langchain-huggingface and set up HuggingFaceEmbeddings with sentence-transformers/all-mpnet-base-v2.

```bash
pip install -qU langchain-huggingface

```

```python
from langchain_huggingface import HuggingFaceEmbeddings

embeddings = HuggingFaceEmbeddings(
    model_name="sentence-transformers/all-mpnet-base-v2",
    encode_kwargs={"normalize_embeddings": True},
)

```

--------------------------------

### Install LangChain using uv

Source: https://docs.langchain.com/oss/python/langchain/quickstart

Initializes a project pinned to Python 3.11 and installs langchain with uv.

```bash
uv python pin 3.11
uv init
uv add langchain
uv sync

```

--------------------------------

### Install and initialize MistralAI embeddings

Source: https://docs.langchain.com/oss/python/langchain/knowledge-base

Install langchain-mistralai and initialize MistralAIEmbeddings with mistral-embed.

```bash
pip install -qU langchain-mistralai

```

```python
import getpass
import os

if not os.environ.get("MISTRALAI_API_KEY"):
    os.environ["MISTRALAI_API_KEY"] = getpass.getpass("Enter API key for MistralAI: ")

from langchain_mistralai import MistralAIEmbeddings

embeddings = MistralAIEmbeddings(model="mistral-embed")

```

--------------------------------

### Install and configure AstraDBVectorStore

Source: https://docs.langchain.com/oss/python/langchain/knowledge-base

Installs langchain-astradb and initializes AstraDBVectorStore with connection credentials and parameters.

```bash
pip install -U "langchain-astradb"

```

```python
from langchain_astradb import AstraDBVectorStore

vector_store = AstraDBVectorStore(
    embedding=embeddings,
    api_endpoint=ASTRA_DB_API_ENDPOINT,
    collection_name="astra_vector_langchain",
    token=ASTRA_DB_APPLICATION_TOKEN,
    namespace=ASTRA_DB_NAMESPACE,
)

```

--------------------------------

### Install pypdf with uv

Source: https://docs.langchain.com/oss/python/langchain/knowledge-base

Add and install the pypdf dependency using uv.

```bash
uv add pypdf

```

--------------------------------

### Install OpenRouter integration

Source: https://docs.langchain.com/oss/python/langchain/multi-agent/skills-sql-assistant

Install the OpenRouter integration package using pip or uv.

```bash
pip install -U "langchain-openrouter"

```

```bash
uv add "langchain-openrouter"

```

--------------------------------

### Install and initialize Chroma vector store

Source: https://docs.langchain.com/oss/python/langchain/knowledge-base

Installs langchain-chroma and creates a persistent Chroma vector store instance.

```bash
pip install -qU langchain-chroma

```

```python
from langchain_chroma import Chroma

vector_store = Chroma(
    collection_name="example_collection",
    embedding_function=embeddings,
    persist_directory="./chroma_langchain_db",  # Where to save data locally, remove if not necessary
)

```

--------------------------------

### Install and initialize Milvus vector store

Source: https://docs.langchain.com/oss/python/langchain/knowledge-base

Installs langchain-milvus and initializes Milvus using a local URI and index parameters.

```bash
pip install -qU langchain-milvus

```

```python
from langchain_milvus import Milvus

URI = "./milvus_example.db"

vector_store = Milvus(
    embedding_function=embeddings,
    connection_args={"uri": URI},
    index_params={"index_type": "FLAT", "metric_type": "L2"},
)

```

--------------------------------

### Install assistant-ui dependencies with Bun

Source: https://docs.langchain.com/oss/python/langchain/frontend/integrations/assistant-ui

Install the core assistant-ui React package and its Markdown renderer using bun.

```bash
bun add @assistant-ui/react @assistant-ui/react-markdown

```

--------------------------------

### Install and initialize Voyage AI embeddings

Source: https://docs.langchain.com/oss/python/langchain/knowledge-base

Install langchain-voyageai and set up VoyageAIEmbeddings with voyage-3.

```bash
pip install -qU langchain-voyageai

```

```python
import getpass
import os

if not os.environ.get("VOYAGE_API_KEY"):
    os.environ["VOYAGE_API_KEY"] = getpass.getpass("Enter API key for Voyage AI: ")

from langchain-voyageai import VoyageAIEmbeddings

embeddings = VoyageAIEmbeddings(model="voyage-3")

```

--------------------------------

### Install OpenAI integration

Source: https://docs.langchain.com/oss/python/langchain/multi-agent/skills-sql-assistant

Install the OpenAI integration package using pip or uv.

```bash
pip install -U "langchain[openai]"

```

```bash
uv add "langchain[openai]"

```

--------------------------------

### Install HuggingFace integration

Source: https://docs.langchain.com/oss/python/langchain/multi-agent/skills-sql-assistant

Install the HuggingFace integration package using pip or uv.

```bash
pip install -U "langchain[huggingface]"

```

```bash
uv add "langchain[huggingface]"

```

--------------------------------

### Install and configure InMemoryVectorStore

Source: https://docs.langchain.com/oss/python/langchain/knowledge-base

Installs langchain-core and instantiates an in-memory vector store with an embedding model.

```bash
pip install -U "langchain-core"

```

```python
from langchain_core.vectorstores import InMemoryVectorStore

vector_store = InMemoryVectorStore(embeddings)

```

--------------------------------

### Install and initialize IBM watsonx embeddings

Source: https://docs.langchain.com/oss/python/langchain/knowledge-base

Install langchain-ibm and initialize WatsonxEmbeddings with model ID, URL, and project ID.

```bash
pip install -qU langchain-ibm

```

```python
import getpass
import os

if not os.environ.get("WATSONX_APIKEY"):
    os.environ["WATSONX_APIKEY"] = getpass.getpass("Enter API key for IBM watsonx: ")

from langchain_ibm import WatsonxEmbeddings

embeddings = WatsonxEmbeddings(
    model_id="ibm/slate-125m-english-rtrvr",
    url="https://us-south.ml.cloud.ibm.com",
    project_id="<WATSONX PROJECT_ID>",
)

```

--------------------------------

### Install and configure PGVector

Source: https://docs.langchain.com/oss/python/langchain/knowledge-base

Installs langchain-postgres and sets up PGVector with PostgreSQL connection parameters.

```bash
pip install -qU langchain-postgres

```

```python
from langchain_postgres import PGVector

vector_store = PGVector(
    embeddings=embeddings,
    collection_name="my_docs",
    connection="postgresql+psycopg://...",
)

```

--------------------------------

### Install and initialize OpenAI embeddings

Source: https://docs.langchain.com/oss/python/langchain/knowledge-base

Install the langchain-openai package and initialize OpenAIEmbeddings with text-embedding-3-large.

```bash
pip install -U "langchain-openai"

```

```python
import getpass
import os

if not os.environ.get("OPENAI_API_KEY"):
    os.environ["OPENAI_API_KEY"] = getpass.getpass("Enter API key for OpenAI: ")

from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings(model="text-embedding-3-large")

```

--------------------------------

### Install Google GenAI integration

Source: https://docs.langchain.com/oss/python/langchain/multi-agent/skills-sql-assistant

Install the Google GenAI integration package using pip or uv.

```bash
pip install -U "langchain[google-genai]"

```

```bash
uv add "langchain[google-genai]"

```

--------------------------------

### Install and configure PGVectorStore with PGEngine

Source: https://docs.langchain.com/oss/python/langchain/knowledge-base

Installs langchain-postgres and creates a synchronous PGVectorStore using PGEngine.

```bash
pip install -qU langchain-postgres

```

```python
from langchain_postgres import PGEngine, PGVectorStore

pg_engine = PGEngine.from_connection_string(
    url="postgresql+psycopg://..."
)

vector_store = PGVectorStore.create_sync(
    engine=pg_engine,
    table_name='test_table',
    embedding_service=embeddings
)

```

--------------------------------

### Install AWS Bedrock integration

Source: https://docs.langchain.com/oss/python/langchain/multi-agent/skills-sql-assistant

Install the AWS Bedrock integration package using pip or uv.

```bash
pip install -U "langchain[aws]"

```

```bash
uv add "langchain[aws]"

```

--------------------------------

### Install project dependencies with uv

Source: https://docs.langchain.com/oss/python/langchain/studio

Install required dependencies for langchain and OpenAI model support via uv.

```bash
uv add langchain langchain-openai

```

--------------------------------

### Install LangGraph CLI with uv

Source: https://docs.langchain.com/oss/python/langchain/studio

Install the LangGraph CLI development server using uv. Requires Python 3.11 or greater.

```bash
# Python >= 3.11 is required.
uv add "langgraph-cli[inmem]"

```

--------------------------------

### Inject user writing style from Store using wrap_model_call

Source: https://docs.langchain.com/oss/python/langchain/context-engineering

Reads user-specific writing style examples from the agent Store and appends a style guide message to the model request for transient context engineering. Configures create_agent with Context schema, InMemoryStore, and the middleware.

```python
from dataclasses import dataclass
from langchain.agents import create_agent
from langchain.agents.middleware import wrap_model_call, ModelRequest, ModelResponse
from typing import Callable
from langgraph.store.memory import InMemoryStore

@dataclass
class Context:
    user_id: str

@wrap_model_call
def inject_writing_style(
    request: ModelRequest,
    handler: Callable[[ModelRequest], ModelResponse]
) -> ModelResponse:
    """Inject user's email writing style from Store."""
    user_id = request.runtime.context.user_id  

    # Read from Store: get user's writing style examples
    store = request.runtime.store  
    writing_style = store.get(("writing_style",), user_id)

    if writing_style:
        style = writing_style.value
        # Build style guide from stored examples
        style_context = f"""Your writing style:
- Tone: {style.get('tone', 'professional')}
- Typical greeting: "{style.get('greeting', 'Hi')}"
- Typical sign-off: "{style.get('sign_off', 'Best')}"
- Example email you've written:
{style.get('example_email', '')}"""

        # Append at end - models pay more attention to final messages
        messages = [
            *request.messages,
            {"role": "user", "content": style_context}
        ]
        request = request.override(messages=messages)

    return handler(request)

agent = create_agent(
    model="gpt-5.5",
    tools=[...],
    middleware=[inject_writing_style],
    context_schema=Context,
    store=InMemoryStore()
)
```

--------------------------------

### Install LangChain using pip

Source: https://docs.langchain.com/oss/python/langchain/quickstart

Installs or updates langchain using pip. Requires Python 3.11+ installed separately if needed.

```bash
# Install Python 3.11+ separately if needed.
pip install -U langchain

```

--------------------------------

### Initialize PostgresStore and pass to create_agent

Source: https://docs.langchain.com/oss/python/langchain/long-term-memory

Create and set up a PostgresStore instance from a connection string and supply it to create_agent.

```python
from langchain.agents import create_agent
from langchain_core.runnables import Runnable
from langgraph.store.postgres import PostgresStore  # type: ignore[import-not-found]

DB_URI = "postgresql://postgres:postgres@localhost:5432/postgres?sslmode=disable"

with PostgresStore.from_conn_string(DB_URI) as store:
    store.setup()
    agent: Runnable = create_agent(
        "claude-sonnet-4-6",
        tools=[],
        store=store,
    )

```

--------------------------------

### Install pypdf with conda

Source: https://docs.langchain.com/oss/python/langchain/knowledge-base

Install the pypdf dependency from the conda-forge channel.

```bash
conda install pypdf -c conda-forge

```

--------------------------------

### Install boto3 and initialize OpenSearchVectorSearch

Source: https://docs.langchain.com/oss/python/langchain/knowledge-base

Sets up AWS authentication and initializes an OpenSearch vector store from existing documents.

```bash
pip install -qU  boto3

```

```python
from opensearchpy import RequestsHttpConnection

service = "es"  # must set the service as 'es'
region = "us-east-2"
credentials = boto3.Session(
    aws_access_key_id="xxxxxx", aws_secret_access_key="xxxxx"
).get_credentials()
awsauth = AWS4Auth("xxxxx", "xxxxxx", region, service, session_token=credentials.token)

vector_store = OpenSearchVectorSearch.from_documents(
    docs,
    embeddings,
    opensearch_url="host url",
    http_auth=awsauth,
    timeout=300,
    use_ssl=True,
    verify_certs=True,
    connection_class=RequestsHttpConnection,
    index_name="test-index",
)

```

--------------------------------

### Configure SkillsMiddleware with Baseten

Source: https://docs.langchain.com/oss/python/langchain/deep-agent-from-scratch

Initialize an agent using Baseten configured with `SkillsMiddleware` pointing to the `/skills/` directory on the backend.

```python
from deepagents.middleware import FilesystemMiddleware, SkillsMiddleware, SummarizationMiddleware

model = "baseten:zai-org/GLM-5.2"

agent = create_agent(
    model=model,
    tools=[],
    middleware=[
        FilesystemMiddleware(backend=backend),
        SummarizationMiddleware(model=model, backend=backend),
        SkillsMiddleware(backend=backend, sources=["/skills/"]),
    ],
)

```

--------------------------------

### Configure agent with Baseten and FilesystemMiddleware

Source: https://docs.langchain.com/oss/python/langchain/agents

Creates an agent backed by Baseten 'zai-org/GLM-5.2' and StateBackend filesystem middleware.

```python
from langchain.agents import create_agent
from deepagents.backends import StateBackend
from deepagents.middleware import FilesystemMiddleware

agent = create_agent(
    model="baseten:zai-org/GLM-5.2",
    tools=[search],
    middleware=[FilesystemMiddleware(backend=StateBackend())],
)

```

--------------------------------

### Install and initialize Nomic embeddings

Source: https://docs.langchain.com/oss/python/langchain/knowledge-base

Install langchain-nomic and instantiate NomicEmbeddings with nomic-embed-text-v1.5.

```bash
pip install -qU langchain-nomic

```

```python
import getpass
import os

if not os.environ.get("NOMIC_API_KEY"):
    os.environ["NOMIC_API_KEY"] = getpass.getpass("Enter API key for Nomic: ")

from langchain_nomic import NomicEmbeddings

embeddings = NomicEmbeddings(model="nomic-embed-text-v1.5")

```

--------------------------------

### Start development server with langgraph dev

Source: https://docs.langchain.com/oss/python/langchain/studio

Start the local development server to connect your agent to Studio. Use --tunnel if accessing via Safari to resolve localhost restrictions.

```bash
langgraph dev

```

--------------------------------

### Install deepagents using pip

Source: https://docs.langchain.com/oss/python/langchain/quickstart

Install or upgrade the deepagents package using pip.

```bash
pip install -U deepagents

```

--------------------------------

### Create a LangChain agent with Baseten

Source: https://docs.langchain.com/oss/python/langchain/overview

Sets up a LangChain agent backed by models hosted on Baseten.

```python
# pip install -qU langchain langchain-baseten
from langchain.agents import create_agent

def get_weather(city: str) -> str:
    """Get weather for a given city."""
    return f"It's always sunny in {city}!"

agent = create_agent(
    model="baseten:zai-org/GLM-5.2",
    tools=[get_weather],
    system_prompt="You are a helpful assistant",
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "What's the weather in San Francisco?"}]}
)
print(result["messages"][-1].content_blocks)

```

--------------------------------

### Install AgentEvals using pip

Source: https://docs.langchain.com/oss/python/langchain/test/evals

Installs or upgrades the agentevals package using pip.

```shell
pip install -U agentevals

```

--------------------------------

### Install Anthropic integration

Source: https://docs.langchain.com/oss/python/langchain/multi-agent/skills-sql-assistant

Install the Anthropic integration package using pip or uv.

```bash
pip install -U "langchain[anthropic]"

```

```bash
uv add "langchain[anthropic]"

```

--------------------------------

### Configure agent with Google GenAI and FilesystemMiddleware

Source: https://docs.langchain.com/oss/python/langchain/agents

Sets up a LangChain agent using Google GenAI model 'gemini-3.6-flash' and attaches FilesystemMiddleware with StateBackend.

```python
from langchain.agents import create_agent
from deepagents.backends import StateBackend
from deepagents.middleware import FilesystemMiddleware

agent = create_agent(
    model="google_genai:gemini-3.6-flash",
    tools=[search],
    middleware=[FilesystemMiddleware(backend=StateBackend())],
)

```

--------------------------------

### Install and configure MongoDBAtlasVectorSearch

Source: https://docs.langchain.com/oss/python/langchain/knowledge-base

Installs langchain-mongodb and configures MongoDB Atlas vector search.

```bash
pip install -qU langchain-mongodb

```

```python
from langchain_mongodb import MongoDBAtlasVectorSearch

vector_store = MongoDBAtlasVectorSearch(
    embedding=embeddings,
    collection=MONGODB_COLLECTION,
    index_name=ATLAS_VECTOR_SEARCH_INDEX_NAME,
    relevance_score_fn="cosine",
)

```

--------------------------------

### Install langgraph-checkpoint-postgres using uv

Source: https://docs.langchain.com/oss/python/langchain/long-term-memory

Add langgraph-checkpoint-postgres and psycopg[binary] dependencies using uv.

```bash
uv add langgraph-checkpoint-postgres "psycopg[binary]"

```

--------------------------------

### Install backend dependencies with uv

Source: https://docs.langchain.com/oss/python/langchain/frontend/integrations/copilotkit

Adds CopilotKit, AG-UI LangGraph, FastAPI, and Uvicorn to the backend project.

```bash
uv add copilotkit ag-ui-langgraph fastapi uvicorn

```

--------------------------------

### Install and initialize Cohere embeddings

Source: https://docs.langchain.com/oss/python/langchain/knowledge-base

Install langchain-cohere and configure CohereEmbeddings using embed-english-v3.0.

```bash
pip install -qU langchain-cohere

```

```python
import getpass
import os

if not os.environ.get("COHERE_API_KEY"):
    os.environ["COHERE_API_KEY"] = getpass.getpass("Enter API key for Cohere: ")

from langchain_cohere import CohereEmbeddings

embeddings = CohereEmbeddings(model="embed-english-v3.0")

```

--------------------------------

### Configure SkillsMiddleware with OpenAI

Source: https://docs.langchain.com/oss/python/langchain/deep-agent-from-scratch

Initialize an agent using OpenAI configured with `SkillsMiddleware` pointing to the `/skills/` directory on the backend.

```python
from deepagents.middleware import FilesystemMiddleware, SkillsMiddleware, SummarizationMiddleware

model = "openai:gpt-5.5"

agent = create_agent(
    model=model,
    tools=[],
    middleware=[
        FilesystemMiddleware(backend=backend),
        SummarizationMiddleware(model=model, backend=backend),
        SkillsMiddleware(backend=backend, sources=["/skills/"]),
    ],
)

```

--------------------------------

### Install and initialize Google Gemini embeddings

Source: https://docs.langchain.com/oss/python/langchain/knowledge-base

Install langchain-google-genai and initialize GoogleGenerativeAIEmbeddings with models/gemini-embedding-001.

```bash
pip install -qU langchain-google-genai

```

```python
import getpass
import os

if not os.environ.get("GOOGLE_API_KEY"):
    os.environ["GOOGLE_API_KEY"] = getpass.getpass("Enter API key for Google Gemini: ")

from langchain_google_genai import GoogleGenerativeAIEmbeddings

embeddings = GoogleGenerativeAIEmbeddings(model="models/gemini-embedding-001")

```

--------------------------------

### Install LangChain and LangGraph dependencies

Source: https://docs.langchain.com/oss/python/langchain/sql-agent

Installs the required base packages for building LangChain agents.

```bash
pip install langchain langgraph

```

--------------------------------

### Install provider integrations using uv

Source: https://docs.langchain.com/oss/python/langchain/install

Adds the langchain-openai and langchain-anthropic partner packages using uv.

```shell
# Installing the OpenAI integration
uv add langchain-openai

# Installing the Anthropic integration
uv add langchain-anthropic

```

--------------------------------

### Project directory structure

Source: https://docs.langchain.com/oss/python/langchain/studio

Example project directory layout for running LangGraph Studio locally.

```plaintext
my-app/
├── src
│   └── agent.py
├── .env
└── langgraph.json

```

--------------------------------

### Install deepagents using uv

Source: https://docs.langchain.com/oss/python/langchain/quickstart

Install the deepagents package into your project using the uv package manager.

```bash
uv add deepagents

```

--------------------------------

### Configure agent with Ollama and FilesystemMiddleware

Source: https://docs.langchain.com/oss/python/langchain/agents

Sets up a locally hosted agent using Ollama 'north-mini-code-1.0' and StateBackend filesystem middleware.

```python
from langchain.agents import create_agent
from deepagents.backends import StateBackend
from deepagents.middleware import FilesystemMiddleware

agent = create_agent(
    model="ollama:north-mini-code-1.0",
    tools=[search],
    middleware=[FilesystemMiddleware(backend=StateBackend())],
)

```

--------------------------------

### View example trace output

Source: https://docs.langchain.com/oss/python/langchain/streaming

Displays the step-by-step execution trace output for an agent run containing model tool calls, tool responses, and final generated output.

```text
step: model
content: [{'type': 'tool_call', 'name': 'get_weather', 'args': {'city': 'San Francisco'}, 'id': 'call_9lBtsDbmmobzyA8xc4I4Ctne'}]
step: tools
content: [{'type': 'text', 'text': "It's always sunny in San Francisco!"}]
step: model
content: [{'type': 'text', 'text': "San Francisco weather: It's always sunny in San Francisco!\n\nIf you’d like the exact current conditions (temperature, humidity, wind) and a short forecast, I can fetch that next. Would you like me to pull live details for San Francisco?"}]

```
Tokens:
Raw