langgraph-project-setup — Claude Code skill: setup
The langgraph-project-setup Claude Code skill scaffolds and configures LangGraph projects. It activates for project structure, langgraph.json, provider variables, dependency setup, and configuration troubleshooting.
MIT ★ 106 updated 2026-11-11
npx skills add soba-labs/langchain-agent-skills --skill langgraph-project-setup -a claude-codeWhat langgraph-project-setup does
The skill creates a LangGraph project skeleton for Python or JavaScript/TypeScript, including directories, langgraph.json, a .env template, dependency files, and starter code. It offers simple and multi-agent layouts. Python initialization uses uv or python3; JavaScript setup runs through node.
Provider settings can be entered with an interactive script or added to .env. The available choices include OpenAI, Anthropic, Google, and AWS Bedrock. An agent needs at least one LLM provider configured. The skill can also validate project settings and start local development with langgraph dev; langgraph up requires Docker and uses PostgreSQL for state persistence.
What it helps with
- scaffold a Python LangGraph project
- set the graph path in
langgraph.json - configure
.envfor an LLM provider - organize a multi-agent project into modules
- validate project settings before local development
Example prompts for the agent
- Create a Python LangGraph project with a multi-agent layout.
- Set up
langgraph.jsonfor my agent and prepare.env. - Check this LangGraph configuration and help start it locally.
How to install langgraph-project-setup
1Skills CLI (Vercel)
npx skills add soba-labs/langchain-agent-skills --skill langgraph-project-setup -a claude-code2Manually: put the files in place
~/.claude/skills/langgraph-project-setup/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/langgraph-project-setup/
1Skills CLI (Vercel)
npx skills add soba-labs/langchain-agent-skills --skill langgraph-project-setup -a codex2Manually: put the files in place
.agents/skills/langgraph-project-setup/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add soba-labs/langchain-agent-skills --skill langgraph-project-setup -a cursor2Manually: put the files in place
.cursor/skills/langgraph-project-setup/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install soba-labs/langchain-agent-skills skills/langgraph-project-setup2Manually: put the files in place
.github/skills/langgraph-project-setup/SKILL.md1Skills CLI (Vercel)
npx skills add soba-labs/langchain-agent-skills --skill langgraph-project-setup -a gemini-cli2Platform CLI
gemini skills install https://github.com/soba-labs/langchain-agent-skills --path skills/langgraph-project-setupManually: put the files in place
.devin/skills/langgraph-project-setup/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add soba-labs/langchain-agent-skills --skill langgraph-project-setup -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about langgraph-project-setup
How do I install langgraph-project-setup in Claude Code?
Run npx skills add soba-labs/langchain-agent-skills --skill langgraph-project-setup -a claude-code. The skill file is placed at ~/.claude/skills/langgraph-project-setup/SKILL.md.
What does langgraph-project-setup do?
It scaffolds LangGraph projects in Python or JavaScript/TypeScript, creates langgraph.json and a .env template, and helps configure dependencies and validate project settings.
What does langgraph-project-setup need to work?
An agent needs at least one configured LLM provider, such as OpenAI or Anthropic. Python initialization uses uv or python3, while JavaScript setup uses node; running langgraph up requires Docker.
Source text
SKILL.md · MIT
---
name: langgraph-project-setup
description: Initialize and configure LangGraph projects with proper structure, langgraph.json configuration, environment variables, and dependency management. Use when users want to (1) create a new LangGraph project, (2) set up langgraph.json for deployment, (3) configure environment variables for LLM providers, (4) initialize project structure for agents, (5) set up local development with LangGraph Studio, (6) configure dependencies (pyproject.toml, requirements.txt, package.json), or (7) troubleshoot project configuration issues.
---
# LangGraph Project Setup
Initialize and configure LangGraph projects for local development and deployment.
## Quick Start
### Python Project
```bash
# Initialize new project
uv run scripts/init_langgraph_project.py my-agent
# Fallback if uv not available
python3 scripts/init_langgraph_project.py my-agent
# Or with options
uv run scripts/init_langgraph_project.py my-agent \
--pattern multiagent \
--python-version 3.12
# Fallback if uv not available
python3 scripts/init_langgraph_project.py my-agent \
--pattern multiagent \
--python-version 3.12
```
### JavaScript Project
```bash
# Initialize new project
node scripts/init_langgraph_project.js my-agent
# TypeScript project
node scripts/init_langgraph_project.js my-agent --typescript
# Multi-agent pattern
node scripts/init_langgraph_project.js my-agent \
--pattern multiagent \
--typescript
```
## Setup Workflow
### Step 1: Choose Project Pattern
**Simple Pattern:** Single agent with straightforward workflow
- Best for: Getting started, prototypes, single-purpose agents
- Structure: Minimal files, agent.py/agent.ts at package root
**Multi-Agent Pattern:** Modular architecture with separated concerns
- Best for: Complex workflows, multiple agents, production applications
- Structure: utils/ directory with state.py, nodes.py, tools.py
### Step 2: Initialize Project
Run the init script with your chosen pattern:
```bash
# Python - simple
uv run scripts/init_langgraph_project.py my-agent
# Fallback if uv not available
python3 scripts/init_langgraph_project.py my-agent
# Python - multi-agent
uv run scripts/init_langgraph_project.py my-agent --pattern multiagent
# Fallback if uv not available
python3 scripts/init_langgraph_project.py my-agent --pattern multiagent
# JavaScript/TypeScript - simple
node scripts/init_langgraph_project.js my-agent --typescript
# JavaScript/TypeScript - multi-agent
node scripts/init_langgraph_project.js my-agent --pattern multiagent --typescript
```
The script creates:
- Project directory structure
- `langgraph.json` configuration
- `.env` template
- Dependency files (pyproject.toml or package.json)
- `.gitignore`
- Boilerplate code with TODO comments
### Step 3: Install Dependencies
**Python:**
```bash
cd my-agent
uv venv --python 3.12
source .venv/bin/activate # On Windows: .venv\Scripts\activate
uv pip install -e '.[dev]'
# Fallback if uv not available
python3 -m venv venv
source venv/bin/activate # On Windows: venv\Scripts\activate
pip install -e '.[dev]'
```
**JavaScript:**
```bash
cd my-agent
npm install # or: yarn install / pnpm install
```
### Step 4: Configure Environment Variables
**Option A: Interactive Setup (Recommended)**
```bash
uv run scripts/setup_providers.py
```
Follow the prompts to configure:
- OpenAI
- Anthropic (Claude)
- Google (Gemini)
- AWS Bedrock
- LangSmith (tracing)
- Tavily (search)
**Option B: Manual Configuration**
Edit `.env` file directly:
```bash
# Required: Choose at least one LLM provider
OPENAI_API_KEY=sk-...
# or
ANTHROPIC_API_KEY=sk-ant-...
# Optional: Enable tracing
LANGSMITH_API_KEY=lsv2_...
LANGSMITH_TRACING=true
LANGSMITH_PROJECT=my-project
```
See `references/provider-configuration.md` for provider-specific setup.
### Step 5: Implement Agent Logic
Replace TODO comments in generated files:
**Python Simple:**
- Edit `my_agent/agent.py`
- Configure LLM in `call_model` function
**Python Multi-Agent:**
- Define state schema in `my_agent/utils/state.py`
- Implement node logic in `my_agent/utils/nodes.py`
- Add tools in `my_agent/utils/tools.py`
- Build graph in `my_agent/agent.py`
**JavaScript/TypeScript:**
- Similar structure in `src/` directory
- Import appropriate LangChain packages
### Step 6: Configure langgraph.json
The init script creates a basic configuration. Customize as needed:
```json
{
"dependencies": ["."],
"graphs": {
"agent": "./my_agent/agent.py:graph"
},
"env": ".env",
"python_version": "3.11"
}
```
**Key configuration options:**
- `dependencies`: Package dependencies location
- `graphs`: Mapping of graph IDs to code paths
- `env`: Path to environment file
- `python_version` or `node_version`: Runtime version
For complete schema reference, see `references/langgraph-json-schema.md`.
### Step 7: Start Development Server
**Option A: langgraph dev (Recommended for development)**
```bash
langgraph dev
```
- No Docker required
- In-memory state persistence
- Hot reloading enabled
- Default port: 2024
**Option B: langgraph up (Production-like testing)**
```bash
langgraph up
```
- Docker required
- PostgreSQL state persistence
- Production environment simulation
- Default port: 8123
### Step 8: Connect to LangGraph Studio
Access Studio in your browser:
```
https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:2024
```
**Safari users:** Use `--tunnel` flag:
```bash
langgraph dev --tunnel
```
## Validation
### Validate Configuration
```bash
uv run scripts/validate_langgraph_config.py
```
Checks:
- Required fields (dependencies, graphs)
- File paths and references
- Optional field formats
- Common configuration errors
### Test Agent Locally
```bash
# Start server
langgraph dev
# In another terminal, test with curl
curl -X POST http://localhost:2024/invoke \
-H "Content-Type: application/json" \
-d '{"input": {"messages": [{"role": "user", "content": "Hello"}]}}'
```
## Common Configurations
### Python with OpenAI
```toml
# pyproject.toml
[project.optional-dependencies]
openai = ["langchain-openai>=1.1.0"]
```
```python
# agent.py
from langchain_openai import ChatOpenAI
model = ChatOpenAI(model="gpt-4o-mini")
```
### Python with Anthropic
```toml
# pyproject.toml
[project.optional-dependencies]
anthropic = ["langchain-anthropic>=1.1.0"]
```
```python
# agent.py
from langchain_anthropic import ChatAnthropic
model = ChatAnthropic(model="claude-haiku-4-5-20251001")
```
### JavaScript with OpenAI
```json
// package.json
{
"dependencies": {
"@langchain/openai": "^1.1.0"
}
}
```
```typescript
// agent.ts
import { ChatOpenAI } from "@langchain/openai";
const model = new ChatOpenAI({ model: "gpt-4o-mini" });
```
## Project Structure Reference
- Python structures: `references/python-project-structure.md`
- JavaScript structures: `references/javascript-project-structure.md`
- langgraph.json schema: `references/langgraph-json-schema.md`
- Provider setup: `references/provider-configuration.md`
- Deployment options: `references/deployment-targets.md`
## Troubleshooting
### "Module not found" errors
Ensure dependencies are installed:
```bash
# Python
uv pip install -e '.[dev]'
# Fallback if uv not available
pip install -e '.[dev]'
# JavaScript
npm install
```
### "Graph not found" in langgraph.json
Check graph path format:
- Python: `./package_name/agent.py:graph`
- JavaScript: `./src/agent.ts:graph`
Validate: `uv run scripts/validate_langgraph_config.py` (fallback: `python3 scripts/validate_langgraph_config.py`)
### Environment variables not loading
- Check `.env` file exists in project root
- Verify `"env": ".env"` in langgraph.json
- Ensure no quotes around values in .env
- Restart development server after changes
### Studio connection issues
- Verify server is running: `langgraph dev`
- Check correct port (default: 2024)
- Safari users: use `--tunnel` flag
- Check firewall/security software
### Hot reload not working
- Ensure using `langgraph dev` (not `langgraph up`)
- Check file is in correct directory
- Try manual restart if needed
## Next Steps
After setup:
1. Implement agent logic (replace TODOs)
2. Add tools and nodes as needed
3. Test with Studio
4. Write tests (see langgraph-testing-evaluation skill)
5. Deploy to LangSmith (see langsmith-deployment skill)
## Scripts Reference
### init_langgraph_project.py
Initialize Python project:
```bash
uv run scripts/init_langgraph_project.py <name> [--pattern simple|multiagent] [--python-version 3.11|3.12|3.13]
# Fallback if uv not available
python3 scripts/init_langgraph_project.py <name> [--pattern simple|multiagent] [--python-version 3.11|3.12|3.13]
```
### init_langgraph_project.js
Initialize JavaScript project:
```bash
node scripts/init_langgraph_project.js <name> [--pattern simple|multiagent] [--typescript]
```
### validate_langgraph_config.py
Validate langgraph.json:
```bash
uv run scripts/validate_langgraph_config.py [path/to/langgraph.json]
# Fallback if uv not available
python3 scripts/validate_langgraph_config.py [path/to/langgraph.json]
```
### setup_providers.py
Interactive provider setup:
```bash
uv run scripts/setup_providers.py [--output .env]
# Fallback if uv not available
python3 scripts/setup_providers.py [--output .env]
```
## Additional Resources
- [LangGraph Documentation](https://docs.langchain.com/langgraph)
- [LangSmith Documentation](https://docs.langchain.com/langsmith)
- [LangGraph CLI Reference](https://docs.langchain.com/langsmith/cli)
- [Application Structure Guide](https://docs.langchain.com/oss/python/langgraph/application-structure)
© soba-labs · MIT · soba-labs/langchain-agent-skills