Langchain Dependencies logo

Langchain Dependencies

OrganizationPopular
langchain-ai
langchain-dependencies

INVOKE THIS SKILL when setting up a new project or when asked about package versions, installation, or dependency management for LangChain, LangGraph, LangSmith, or Deep Agents. Covers required packages, minimum versions, environment requirements, versioning best practices, and common community tool packages for both Python and TypeScript.

Overview

Publisherlangchain-ai
Repositorylangchain-skills
Skill namelangchain-dependencies
Stars
1.2K
Forks
95
Bundled files
Instructions only
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • Self-contained

    Everything the model needs lives in the instructions — no extra files to sync.

  • Open source

    Published by langchain-ai on GitHub. Read the source before you install it.

Installation

Install the Langchain Dependencies AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/langchain-ai/langchain-skills.git /tmp/langchain-skills
mkdir -p .claude/skills
cp -r /tmp/langchain-skills/config/skills/langchain-dependencies .claude/skills/langchain-dependencies
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Langchain Dependencies in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Langchain Dependencies on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Langchain Dependencies is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Key principles:

  • LangChain 1.0 is the current LTS release. Always start new projects on 1.0+. LangChain 0.3 is legacy maintenance-only — do not use it for new work.
  • langchain-core is the shared foundation: always install it explicitly alongside any other package.
  • langchain-community (Python only) does NOT follow semantic versioning; pin it conservatively.
  • LangGraph vs Deep Agents: choose one orchestration approach based on your use case — they are alternatives, not a required stack (see Framework Choice below).
  • Provider integrations (model, vector store, tools) are installed separately so you only pull in what you use.

Environment Requirements

RequirementPythonTypeScript / Node
Runtime minimumPython 3.10+Node.js 20+
LangChain1.0+ (LTS)1.0+ (LTS)
LangSmith SDK>= 0.3.0>= 0.3.0

Framework Choice

FrameworkWhen to useCore extra package
LangGraphNeed fine-grained graph control, custom workflows, loops, or branchinglanggraph / @langchain/langgraph
Deep AgentsWant batteries-included planning, memory, file context, and skills out of the boxdeepagents (depends on LangGraph; installs it as a transitive dep)

Both sit on top of langchain + langchain-core + langsmith.


Core Packages

Python — always required

PackageRoleMin version
langchainAgents, chains, retrieval1.0
langchain-coreBase types & interfaces (peer dep)1.0
langsmithTracing, evaluation, datasets0.3.0

Python — orchestration (pick one)

PackageUse whenMin version
langgraphBuilding custom graphs directly1.0
deepagentsUsing the Deep Agents frameworklatest

Python — model providers (pick the one(s) you use)

PackageProvider
langchain-openaiOpenAI (GPT-4o, o3, …)
langchain-anthropicAnthropic (Claude)
langchain-google-genaiGoogle (Gemini)
langchain-mistralaiMistral
langchain-groqGroq (fast inference)
langchain-cohereCohere
langchain-fireworksFireworks AI
langchain-togetherTogether AI
langchain-huggingfaceHugging Face Hub
langchain-ollamaOllama (local models)
langchain-awsAWS Bedrock
langchain-azure-aiAzure AI Foundry

Python — common tool & retrieval packages

These packages have tighter compatibility requirements — use the latest available version unless you have a specific reason not to.

PackageAddsNotes
langchain-tavilyTavily web search (TavilySearch)Dedicated integration package; prefer latest
langchain-text-splittersText chunking utilitiesSemver, keep current
langchain-community1000+ integrations (fallback)NOT semver — pin to minor series
faiss-cpuFAISS vector store (local)Via langchain-community; use latest
langchain-chromaChroma vector storeDedicated integration package; prefer latest
langchain-pineconePinecone vector storeDedicated integration package; prefer latest
langchain-qdrantQdrant vector storeDedicated integration package; prefer latest
langchain-weaviateWeaviate vector storeDedicated integration package; prefer latest
langsmith[pytest]pytest plugin for LangSmithRequires langsmith >= 0.3.4

langchain-community stability note: This package is NOT on semantic versioning. Minor releases can contain breaking changes. Prefer dedicated integration packages (e.g. langchain-chroma, langchain-tavily) when they exist — they are independently versioned and more stable.

TypeScript — always required

PackageRoleMin version
@langchain/coreBase types & interfaces (peer dep)1.0
langchainAgents, chains, retrieval1.0
langsmithTracing, evaluation, datasets0.3.0

TypeScript — orchestration (pick one)

PackageUse whenMin version
@langchain/langgraphBuilding custom graphs directly1.0
deepagentsUsing the Deep Agents frameworklatest

TypeScript — model providers (pick the one(s) you use)

PackageProvider
@langchain/openaiOpenAI (GPT-4o, o3, …)
@langchain/anthropicAnthropic (Claude)
@langchain/google-genaiGoogle (Gemini)
@langchain/mistralaiMistral
@langchain/groqGroq (fast inference)
@langchain/cohereCohere
@langchain/awsAWS Bedrock
@langchain/azure-openaiAzure OpenAI
@langchain/ollamaOllama (local models)

TypeScript — common tool & retrieval packages

PackageAddsNotes
@langchain/tavilyTavily web search (TavilySearch)Dedicated integration package; prefer latest
@langchain/communityBroad set of community integrationsUse sparingly; prefer dedicated packages
@langchain/pineconePinecone vector storeDedicated integration package; prefer latest
@langchain/qdrantQdrant vector storeDedicated integration package; prefer latest
@langchain/weaviateWeaviate vector storeDedicated integration package; prefer latest

@langchain/core must be installed explicitly in yarn workspaces and monorepos — it is a peer dependency and will not always be hoisted automatically.


Minimal Project Templates

# 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, e.g.:
# langchain-openai
# langchain-anthropic
# langchain-google-genai
json
{
  "dependencies": {
    "@langchain/core": "^1.0.0",
    "langchain": "^1.0.0",
    "@langchain/langgraph": "^1.0.0",
    "langsmith": "^0.3.0"
  }
}
# requirements.txt
deepagents            # bundles langgraph internally
langchain>=1.0,<2.0
langchain-core>=1.0,<2.0
langsmith>=0.3.0

# Add your model provider, e.g.:
# langchain-anthropic
# langchain-openai
json
{
  "dependencies": {
    "deepagents": "latest",
    "@langchain/core": "^1.0.0",
    "langchain": "^1.0.0",
    "langsmith": "^0.3.0"
  }
}
# requirements.txt
langchain>=1.0,<2.0
langchain-core>=1.0,<2.0
langgraph>=1.0,<2.0
langsmith>=0.3.0

# Web search
langchain-tavily          # use latest; partner package, semver

# Vector store — pick one:
langchain-chroma          # use latest; partner package, semver
# langchain-pinecone      # use latest; partner package, semver
# langchain-qdrant        # use latest; partner package, semver

# Text processing
langchain-text-splitters  # use latest; semver

# Your model provider:
# langchain-openai / langchain-anthropic / etc.
json
{
  "dependencies": {
    "@langchain/core": "^1.0.0",
    "langchain": "^1.0.0",
    "@langchain/langgraph": "^1.0.0",
    "langsmith": "^0.3.0",
    "@langchain/tavily": "latest",
    "@langchain/pinecone": "latest"
  }
}

Versioning Policy & Upgrade Strategy

Package groupVersioningSafe upgrade strategy
langchain, langchain-coreStrict semver (1.0 LTS)Allow minor: >=1.0,<2.0
langgraph / @langchain/langgraphStrict semver (v1 LTS)Allow minor: >=1.0,<2.0
langsmithStrict semverAllow minor: >=0.3.0
Dedicated integration packages (e.g. langchain-tavily, langchain-chroma)Independently versionedAllow minor updates; use latest
langchain-communityNOT semverPin exact minor: >=0.4.0,<0.5.0
deepagentsFollow project releasesPin to tested version in production

Breaking changes only happen in major versions (1.x → 2.x) for all semver-compliant packages. Deprecated features remain functional across the entire 1.x series with warnings.

Prefer dedicated integration packages over langchain-community. When a dedicated package exists (e.g. langchain-chroma instead of langchain-community's Chroma integration), use it — dedicated packages are independently versioned and better tested.

Community tool packages (Tavily, vector stores, etc.) should be kept at latest unless your project requires a locked environment. These packages frequently release compatibility fixes alongside LangChain/LangGraph updates.


Environment Variables

bash
# 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>          # for Tavily search
PINECONE_API_KEY=<your-key>        # for Pinecone

Common Mistakes

# WRONG: legacy, no new features, security patches only
langchain>=0.3,<0.4

# CORRECT: LangChain 1.0 LTS
langchain>=1.0,<2.0
# WRONG: allows minor-version updates that may be breaking
langchain-community>=0.4

# CORRECT: pin to exact minor series
langchain-community>=0.4.0,<0.5.0

Also consider switching to the equivalent dedicated integration package if one exists (e.g. langchain-chroma instead of the community Chroma integration).

# RISKY: old pin may be incompatible with LangChain 1.0
langchain-tavily==0.0.1

# BETTER: allow latest within the current major
langchain-tavily>=0.1
python
# WRONG — deprecated community import path
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_community.tools import WikipediaQueryRun
from langchain_community.vectorstores import Chroma
from langchain_community.vectorstores import Pinecone

# CORRECT — use dedicated package imports
from langchain_tavily import TavilySearch                  # pip: langchain-tavily (TavilySearchResults is deprecated)
from langchain_community.tools import WikipediaQueryRun  # no dedicated pkg yet
from langchain_chroma import Chroma                       # pip: langchain-chroma
from langchain_pinecone import PineconeVectorStore        # pip: langchain-pinecone

To find the current canonical import for any integration, search the integrations directory: https://python.langchain.com/docs/integrations/tools/

Each entry shows the correct package and import path. If a dedicated package exists, use it — the community path may still work but is considered legacy.

json
// WRONG: missing @langchain/core (breaks in yarn workspaces / strict hoisting)
{
  "dependencies": {
    "@langchain/langgraph": "^1.0.0"
  }
}

// CORRECT: always list @langchain/core explicitly
{
  "dependencies": {
    "@langchain/core": "^1.0.0",
    "@langchain/langgraph": "^1.0.0"
  }
}
python
# Verify before installing
import sys
assert sys.version_info >= (3, 10), "Python 3.10+ required for LangChain 1.0"
bash
# Verify before installing
node --version   # must be v20.x or higher

Frequently asked questions

What does the Langchain Dependencies AI skill do?

INVOKE THIS SKILL when setting up a new project or when asked about package versions, installation, or dependency management for LangChain, LangGraph, LangSmith, or Deep Agents. Covers required packages, minimum versions, environment requirements, versioning best practices, and common community tool packages for both Python and TypeScript.

Why use Langchain Dependencies on TypingMind?

Because you install it once and use it with any model. Langchain Dependencies is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Langchain Dependencies in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/langchain-ai/langchain-skills/tree/main/config/skills/langchain-dependencies. TypingMind reads its SKILL.md and installs it as a skill you can enable per chat.

Which AI models can use Langchain Dependencies?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Langchain Dependencies?

As many as you like. As long as a model supports skills, you can use Langchain Dependencies with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Langchain Dependencies AI skill free?

It is published on GitHub by langchain-ai. Check the repository for licensing terms. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇