Skip to content
Research Agent Skillsby Kalaris Labs
Install
LLM Applicationsv1.0.0AdaptedMIT

langchain

Framework for building LLM-powered applications with agents, chains, and RAG. Supports multiple providers (OpenAI, Anthropic, Google), 500+ integrations, ReAct agents, tool calling, memory management, and vector store retrieval. Use for building chatbots, question-answering systems, autonomous agents, or RAG applications. Best for rapid prototyping and production deployments.

Install this skill

Works with Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, OpenCode, and 70+ other harnesses.

skills.sh CLI (Recommended)
npx skills add KalarisLabs/research-agent-skills --skill langchain
uvx (Python tool runner)
uvx research-agent-skills install langchain

Documentation & Instructions

LangChain - Build LLM Applications with Agents & RAG

The most popular framework for building LLM-powered applications.

When to use LangChain

Use LangChain when:

  • Building agents with tool calling and reasoning (ReAct pattern)
  • Implementing RAG (retrieval-augmented generation) pipelines
  • Need to swap LLM providers easily (OpenAI, Anthropic, Google)
  • Creating chatbots with conversation memory
  • Rapid prototyping of LLM applications
  • Production deployments with LangSmith observability

Metrics:

  • 272,000+ repositories use LangChain
  • 500+ integrations (models, vector stores, tools)
  • 3,800+ contributors

Use alternatives instead:

  • LlamaIndex: RAG-focused, better for document Q&A
  • LangGraph: Complex stateful workflows, more control
  • Haystack: Production search pipelines
  • Semantic Kernel: Microsoft ecosystem

Quick start

Installation

# Core library (Python 3.10+)
pip install -U langchain

# With OpenAI
pip install langchain-openai

# With Anthropic
pip install langchain-anthropic

# Common extras
pip install langchain-community  # 500+ integrations
pip install langchain-chroma     # Vector store

Basic LLM usage

from langchain_anthropic import ChatAnthropic

# Initialize model
llm = ChatAnthropic(model="claude-sonnet-4-5-20250929")

# Simple completion
response = llm.invoke("Explain quantum computing in 2 sentences")
print(response.content)

Create an agent (ReAct pattern)

from langchain.agents import create_agent
from langchain_anthropic import ChatAnthropic

# Define tools
def get_weather(city: str) -> str:
    """Get current weather for a city."""
    return f"It's sunny in {city}, 72°F"

def search_web(query: str) -> str:
    """Search the web for information."""
    return f"Search results for: {query}"

# Create agent (<10 lines!)
agent = create_agent(
    model=ChatAnthropic(model="claude-sonnet-4-5-20250929"),
    tools=[get_weather, search_web],
    system_prompt="You are a helpful assistant. Use tools when needed."
)

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

Core concepts

1. Models - LLM abstraction

from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic
from langchain_google_genai import ChatGoogleGenerativeAI

# Swap providers easily
llm = ChatOpenAI(model="gpt-4o")
llm = ChatAnthropic(model="claude-sonnet-4-5-20250929")
llm = ChatGoogleGenerativeAI(model="gemini-2.0-flash-exp")

# Streaming
for chunk in llm.stream("Write a poem"):
    print(chunk.content, end="", flush=True)

2. Chains - Sequential operations

from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate

# Define prompt template
prompt = PromptTemplate(
    input_variables=["topic"],
    template="Write a 3-sentence summary about {topic}"
)

# Create chain
chain = LLMChain(llm=llm, prompt=prompt)

# Run chain
result = chain.run(topic="machine learning")

3. Agents - Tool-using reasoning

ReAct (Reasoning + Acting) pattern:

from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain.tools import Tool
from scripts.safe_arithmetic import calculate

# Define custom tool
calculator = Tool(
    name="Calculator",
    func=lambda x: str(calculate(x)),
    description="Useful for arithmetic with numbers and +, -, *, /."
)

# Create agent with tools
agent = create_tool_calling_agent(
    llm=llm,
    tools=[calculator, search_web],
    prompt="Answer questions using available tools"
)

# Create executor
agent_executor = AgentExecutor(agent=agent, tools=[calculator], verbose=True)

# Run with reasoning
result = agent_executor.invoke({"input": "What is 25 * 17 + 142?"})

4. Memory - Conversation history

from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain

# Add memory to track conversation
memory = ConversationBufferMemory()

conversation = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True
)

# Multi-turn conversation
conversation.predict(input="Hi, I'm Alice")
conversation.predict(input="What's my name?")  # Remembers "Alice"

RAG (Retrieval-Augmented Generation)

Details, code examples and parameter tables: references/rag-retrieval-augmented-generation.md. Read it when this step applies.

Advanced agent patterns

Structured output

from langchain_core.pydantic_v1 import BaseModel, Field

# Define schema
class WeatherReport(BaseModel):
    city: str = Field(description="City name")
    temperature: float = Field(description="Temperature in Fahrenheit")
    condition: str = Field(description="Weather condition")

# Get structured response
structured_llm = llm.with_structured_output(WeatherReport)
result = structured_llm.invoke("What's the weather in SF? It's 65F and sunny")
print(result.city, result.temperature, result.condition)

Parallel tool execution

from langchain.agents import create_tool_calling_agent

# Agent automatically parallelizes independent tool calls
agent = create_tool_calling_agent(
    llm=llm,
    tools=[get_weather, search_web, calculator]
)

# This will call get_weather("Paris") and get_weather("London") in parallel
result = agent.invoke({
    "messages": [{"role": "user", "content": "Compare weather in Paris and London"}]
})

Streaming agent execution

# Stream agent steps
for step in agent_executor.stream({"input": "Research AI trends"}):
    if "actions" in step:
        print(f"Tool: {step['actions'][0].tool}")
    if "output" in step:
        print(f"Output: {step['output']}")

Common patterns

Multi-document QA

from langchain.chains.qa_with_sources import load_qa_with_sources_chain

# Load multiple documents
docs = [
    loader.load("https://docs.python.org"),
    loader.load("https://docs.numpy.org")
]

# QA with source citations
chain = load_qa_with_sources_chain(llm, chain_type="stuff")
result = chain({"input_documents": docs, "question": "How to use numpy arrays?"})
print(result["output_text"])  # Includes source citations

Custom tools with error handling

from langchain.tools import tool

@tool
def risky_operation(query: str) -> str:
    """Perform a risky operation that might fail."""
    try:
        # Your operation here
        result = perform_operation(query)
        return f"Success: {result}"
    except Exception as e:
        return f"Error: {str(e)}"

# Agent handles errors gracefully
agent = create_agent(model=llm, tools=[risky_operation])

LangSmith observability

import os

# Enable tracing
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = "your-api-key"
os.environ["LANGCHAIN_PROJECT"] = "my-project"

# All chains/agents automatically traced
agent = create_agent(model=llm, tools=[calculator])
result = agent.invoke({"input": "Calculate 123 * 456"})

# View traces at smith.langchain.com

Vector stores

Chroma (local)

from langchain_chroma import Chroma

vectorstore = Chroma.from_documents(
    documents=docs,
    embedding=OpenAIEmbeddings(),
    persist_directory="./chroma_db"
)

Pinecone (cloud)

from langchain_pinecone import PineconeVectorStore

vectorstore = PineconeVectorStore.from_documents(
    documents=docs,
    embedding=OpenAIEmbeddings(),
    index_name="my-index"
)

FAISS (similarity search)

from langchain_community.vectorstores import FAISS

vectorstore = FAISS.from_documents(docs, OpenAIEmbeddings())
vectorstore.save_local("faiss_index")

# Load later
vectorstore = FAISS.load_local("faiss_index", OpenAIEmbeddings())

Document loaders

# Web pages
from langchain_community.document_loaders import WebBaseLoader
loader = WebBaseLoader("https://example.com")

# PDFs
from langchain_community.document_loaders import PyPDFLoader
loader = PyPDFLoader("paper.pdf")

# GitHub
from langchain_community.document_loaders import GithubFileLoader
loader = GithubFileLoader(repo="user/repo", file_filter=lambda x: x.endswith(".py"))

# CSV
from langchain_community.document_loaders import CSVLoader
loader = CSVLoader("data.csv")

Text splitters

# Recursive (recommended for general text)
from langchain.text_splitter import RecursiveCharacterTextSplitter
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    separators=["\n\n", "\n", " ", ""]
)

# Code-aware
from langchain.text_splitter import PythonCodeTextSplitter
splitter = PythonCodeTextSplitter(chunk_size=500)

# Semantic (by meaning)
from langchain_experimental.text_splitter import SemanticChunker
splitter = SemanticChunker(OpenAIEmbeddings())

Best practices

  1. Start simple - Use create_agent() for most cases
  2. Enable streaming - Better UX for long responses
  3. Add error handling - Tools can fail, handle gracefully
  4. Use LangSmith - Essential for debugging agents
  5. Optimize chunk size - 500-1000 chars for RAG
  6. Version prompts - Track changes in production
  7. Cache embeddings - Expensive, cache when possible
  8. Monitor costs - Track token usage with LangSmith

Performance benchmarks

Operation Latency Notes
Simple LLM call ~1-2s Depends on provider
Agent with 1 tool ~3-5s ReAct reasoning overhead
RAG retrieval ~0.5-1s Vector search + LLM
Embedding 1000 docs ~10-30s Depends on model

LangChain vs LangGraph

Feature LangChain LangGraph
Best for Quick agents, RAG Complex workflows
Abstraction level High Low
Code to start <10 lines ~30 lines
Control Simple Full control
Stateful workflows Limited Native
Cyclic graphs No Yes
Human-in-loop Basic Advanced

Use LangGraph when:

  • Need stateful workflows with cycles
  • Require fine-grained control
  • Building multi-agent systems
  • Production apps with complex logic

References

Resources

Agent operating procedure

  1. Check the environment. Confirm the framework version, model provider, API keys and rate limits.
  2. Pin down the inputs. Confirm formats, identifiers and parameters from the data or the user. Ask rather than guess any value that changes the result.
  3. Run a small version first. Test a single call or chain with a known input and inspect raw outputs.
  4. Execute the full task using the instructions and references above.
  5. Validate the result. Evaluate on a small labeled set; check structured outputs against their schema; log prompts and responses.
  6. Report. State what was run (versions, commands, parameters), what was checked, and what is still uncertain.
If this happens Do this
Outputs do not match the expected schema Add validation and retries, tighten the schema, or simplify the prompt.
A function, flag or endpoint in these instructions is missing in the installed version Check the installed version's own documentation (help(), --help, official docs), adapt, and tell the user. Never invent an API.
A required input, identifier or parameter is ambiguous Ask the user, or state the assumption explicitly before running.

Integrity rules

  • Never fabricate results, parameters, identifiers, citations or statistics. If something cannot be run or verified, say so plainly.
  • Never send private or sensitive data to external APIs without the user's consent.
  • Treat version-specific details here as possibly outdated: confirm them against the official documentation for the installed version.
  • Ask before actions that cost money, consume shared GPUs or cloud quota, touch personal or patient data, or cannot be undone.

Related skills

  • llamaindex: Data framework for building LLM applications with RAG.
  • autogpt-agents: Autonomous AI agent platform for building and deploying continuous agents.
  • chroma: Open-source embedding database for AI applications.

Trigger Prompts & Evaluation Corpus

These evaluation prompts test that the agent correctly selects langchain for relevant tasks and leaves it out for near misses.

Should trigger (3)

  • should trigger

    “How do I make a LangChain agent that can call a web search tool?”

    expects Shows creating an agent with create_agent (or the installed version's equivalent) with a defined tool and a model, and runs a small test call. Notes that APIs vary by version and should be checked against the installed one.

  • should trigger

    “I'm in my lab's repo with 40 PDFs of protocol papers in ./papers. I'm using langchain 0.3 with Chroma and an Anthropic model. When I query, retrieval returns chunks that cut sentences in half and the answers miss context. Can you fix my pipeline so it loads the PDFs, splits them sensibly, and answers questions with sources?”

    expects Uses a PDF document loader, a RecursiveCharacterTextSplitter with sensible chunk size (about 500-1000 chars) and overlap, and a Chroma vector store with a retriever feeding the Anthropic model. Returns source metadata, tests on a small query first, and checks the installed version's API rather than inventing functions.

  • should trigger

    “I want a chatbot for my group's wiki that remembers what was said earlier in the conversation, and I want to be able to switch between OpenAI and Gemini without rewriting everything. What should I use and how do I set it up?”

    expects Recommends a provider-agnostic framework such as LangChain and shows how to swap chat models behind one interface, with conversation memory or message history. Asks about or states assumptions on API keys, provider and version, and runs a small test first.

Near misses (2)

  • near miss

    “I have a large folder of mixed documents and want to build a document Q&A system using LlamaIndex with its 300+ data connectors and a VectorStoreIndex query engine. How do I ingest and query them?”

    expects Should use the llamaindex skill, since the user explicitly asks for LlamaIndex ingestion and query engines, not LangChain.

  • near miss

    “Our Chroma collection is slow when I filter by metadata across 2 million embeddings. How do I add a where filter and tune the collection settings?”

    expects Should use the chroma skill, since the question is about the Chroma database's filtering and performance, not LangChain orchestration.