Langchain Oss Primer

<overview> Always load this skill first. This is the required starting point for any LangChain open source agent project — before choosing other skills, before writing code, before installing packages.

It answers three questions every project must resolve upfront:

1. Which framework? — LangChain, LangGraph, or Deep Agents 2. Which agent archetype? — maps your use case to the right API and patterns 3. What to install and which skills to load next

Load this skill first. Once you've decided on a framework and agent type, follow the "Next Skills" section at the bottom — it tells you exactly which skills to invoke next based on your choices.

</overview>

---

Step 1 — Pick Your Framework

The three frameworks are layered, not competing. Each builds on the one below:

┌─────────────────────────────────────────┐
│              Deep Agents                │  ← batteries included
│   (planning, memory, skills, files)     │
├─────────────────────────────────────────┤
│               LangGraph                 │  ← custom orchestration
│    (nodes, edges, state, persistence)   │
├─────────────────────────────────────────┤
│               LangChain                 │  ← foundation
│      (models, tools, prompts, RAG)      │
└─────────────────────────────────────────┘

<framework-decision>

Answer these questions in order:

Higher layers depend on lower ones only when necessary — you can mix them. A LangGraph graph can be a subagent inside Deep Agents; LangChain tools work inside both.

</framework-decision>

<framework-profiles>

Middleware is a concept specific to Deep Agents (explicit middleware layer). LangGraph has no middleware — behavior is wired directly into nodes and edges. If a user asks for built-in hooks or automatic middleware, route to Deep Agents.

</framework-profiles>

---

Step 2 — Pick Your Agent Archetype

Once you've chosen a framework, match your use case to the right API and pattern.

<langchain-archetypes>

LangChain — use create_agent()

Best for single-purpose agents in a ReACT style with a fixed tool set. No built-in planning, memory management, or delegation.

All LangChain agents use create_agent(model, tools=[...]). Next skill: `langchain-fundamentals`.

</langchain-archetypes>

<langgraph-archetypes>

LangGraph — use StateGraph

Best when you need explicit, deterministic control flow.

LangGraph agents use StateGraph(State) with explicit add_node, add_edge, add_conditional_edges. Next skill: `langgraph-fundamentals`.

</langgraph-archetypes>

<deep-agents-archetypes>

Deep Agents — use create_deep_agent()

Best when the agent needs to manage its own work: planning tasks, remembering users across sessions, delegating to specialists, or managing files autonomously.

All Deep Agents use create_deep_agent(model, tools=[...], ...). Next skill: `deep-agents-core` — load it immediately after deciding on Deep Agents.

<deep-agents-middleware>

Deep Agents built-in middleware

Six components pre-wired out of the box. First three are always active; the rest are opt-in:

You configure middleware — you don't implement it.

</deep-agents-middleware>

<mixing-note> You can combine layers in the same project. The most common pattern: Deep Agents as the top-level orchestrator, with a compiled LangGraph graph registered as a specialized subagent. LangChain tools and chains are usable at every level. </mixing-note>

</deep-agents-archetypes>

---

Step 3 — Set Up Your Dependencies

Environment requirements

Always use LangChain 1.0+. LangChain 0.3 is maintenance-only until December 2026 — do not start new projects on it.

---

Core packages — always required

<python-core> Python

</python-core>

<typescript-core> TypeScript

</typescript-core>

---

Orchestration — add based on your framework choice

<orchestration-packages>

</orchestration-packages>

---

Model providers — pick the one(s) you use

<provider-packages>

</provider-packages>

---

Common tools & retrieval — add as needed

<tool-packages>

Prefer dedicated integration packages over langchain-community when one exists — they are independently versioned and more stable.

</tool-packages>

---

Dependency templates

<ex-langchain-python> <python> LangChain agent — provider-agnostic starting point.

# requirements.txt
langchain>=1.0,<2.0
langchain-core>=1.0,<2.0
langsmith>=0.3.0

# Add your model provider:
# langchain-openai | langchain-anthropic | langchain-google-genai | ...

# Add tools/retrieval as needed:
# langchain-tavily | langchain-chroma | langchain-text-splitters | ...

</python> </ex-langchain-python>

<ex-langgraph-python> <python> LangGraph project — provider-agnostic starting point.

# requirements.txt
langchain>=1.0,<2.0
langchain-core>=1.0,<2.0
langgraph>=1.0,<2.0
langsmith>=0.3.0

# Add your model provider:
# langchain-openai | langchain-anthropic | langchain-google-genai | ...

</python> </ex-langgraph-python>

<ex-langgraph-typescript> <typescript> LangGraph project — provider-agnostic starting point.

{
  "dependencies": {
    "@langchain/core": "^1.0.0",
    "langchain": "^1.0.0",
    "@langchain/langgraph": "^1.0.0",
    "langsmith": "^0.3.0"
  }
}

</typescript> </ex-langgraph-typescript>

<ex-deepagents-python> <python> Deep Agents project — provider-agnostic starting point.

# requirements.txt
deepagents
langchain>=1.0,<2.0
langchain-core>=1.0,<2.0
langsmith>=0.3.0

# Add your model provider:
# langchain-openai | langchain-anthropic | langchain-google-genai | ...

</python> </ex-deepagents-python>

<ex-deepagents-typescript> <typescript> Deep Agents project — provider-agnostic starting point.

{
  "dependencies": {
    "deepagents": "latest",
    "@langchain/core": "^1.0.0",
    "langchain": "^1.0.0",
    "langsmith": "^0.3.0"
  }
}

</typescript> </ex-deepagents-typescript>

---

Step 4 — Set Your Environment Variables

<environment-variables>

# LangSmith — always recommended for observability
LANGSMITH_API_KEY=<your-key>
LANGSMITH_PROJECT=<project-name>    # optional, defaults to "default"

# Model provider — set the one(s) you use
OPENAI_API_KEY=<your-key>
ANTHROPIC_API_KEY=<your-key>
GOOGLE_API_KEY=<your-key>
MISTRAL_API_KEY=<your-key>
GROQ_API_KEY=<your-key>
COHERE_API_KEY=<your-key>
FIREWORKS_API_KEY=<your-key>
TOGETHER_API_KEY=<your-key>
HUGGINGFACEHUB_API_TOKEN=<your-key>

# Common tool/retrieval services
TAVILY_API_KEY=<your-key>
PINECONE_API_KEY=<your-key>

</environment-variables>

---

Step 5 — Load the Right Skill Next

Based on the framework and archetype you chose above, invoke these skills now before writing any code:

<next-skills>

If you chose LangChain

If you chose LangGraph

If you chose Deep Agents

Always load `deep-agents-core` first — it is the mandatory starting point for any Deep Agents project.

</next-skills>