An opinionated development framework for building production-ready AI agents with LangGraph. It grounds AI coding assistants (Cursor, Windsurf, Cline) and guides them to use local, official documentation, ensuring reliable, secure, and observable agentic workflows.
git clone https://github.com/botingw/langgraph-dev-navigator.gitThe langgraph-dev-navigator is an opinionated development framework designed to facilitate the creation of production-ready AI agents using LangGraph. This skill empowers developers and AI practitioners by grounding AI coding assistants like Cursor, Windsurf, and Cline in local, official documentation. By ensuring that these agents utilize reliable and secure resources, the framework promotes observable workflows that enhance overall productivity and efficiency in AI automation tasks. One of the key benefits of the langgraph-dev-navigator is its ability to streamline the development process for AI agents. With an implementation time of just 30 minutes, this skill allows teams to quickly set up their workflows without extensive overhead. Although specific time savings are not quantified, the structured approach it offers can lead to significant reductions in development time by minimizing errors and enhancing the reliability of the coding assistants. This skill is particularly beneficial for developers, product managers, and AI practitioners who are involved in creating and deploying AI automation solutions. By utilizing langgraph-dev-navigator, teams can ensure that their AI agents are not only effective but also compliant with best practices in security and observability. The skill is well-suited for those looking to enhance their workflow automation processes and integrate AI agents into their existing systems seamlessly. In practical terms, the langgraph-dev-navigator can be used in various scenarios, such as developing chatbots, automating data analysis, or creating intelligent customer support systems. The intermediate complexity of this skill means that users should have a foundational understanding of AI development principles. As organizations increasingly adopt AI-first workflows, integrating this skill can significantly enhance the capabilities of teams, allowing them to leverage AI automation more effectively in their projects.
[{"step":"Define your use case and components","action":"Replace [USE_CASE] with your specific scenario (e.g., 'multi-tool agent for code review'). List the tools/APIs you need (e.g., GitHub API, local codebase index).","tip":"Start small: build a single-node agent first, then expand to a multi-node graph. Use the official LangGraph docs to validate your component choices."},{"step":"Set up the development environment","action":"Install LangGraph and dependencies: `pip install langgraph langchain-community openinference-sdk`. Create a `config.yaml` file with your API keys and local paths (e.g., `documentation_path: ./docs/v2.1.3`).","tip":"Use a virtual environment to avoid dependency conflicts. Pin versions in `requirements.txt` to match the official docs."},{"step":"Implement the graph with observability","action":"Use the `LangGraphDeveloperNavigator` class to scaffold your graph. Add nodes for each tool/API, and configure error handling (retries, fallbacks) and observability (traces, metrics).","tip":"Start with a minimal state schema (e.g., just `input` and `output`). Add metadata (e.g., `trace_id`) as you iterate."},{"step":"Test and validate","action":"Run the agent locally using `langgraph test --config ./config.yaml --input ./test_cases.jsonl`. Verify that all nodes handle edge cases (e.g., API timeouts, invalid inputs).","tip":"Use the `langgraph` CLI to generate a test report with coverage metrics. Compare outputs against expected results in `test_cases.jsonl`."},{"step":"Package and deploy","action":"Containerize the agent with Docker, exposing a FastAPI endpoint. Deploy to your preferred platform (e.g., Kubernetes, AWS ECS) with health checks and auto-scaling.","tip":"Use the official LangGraph deployment guide to configure secrets management (e.g., AWS Secrets Manager) and logging (e.g., CloudWatch)."}]
No install command available. Check the GitHub repository for manual installation instructions.
git clone https://github.com/botingw/langgraph-dev-navigatorCopy the install command above and run it in your terminal.
Launch Claude Code, Cursor, or your preferred AI coding agent.
Use the prompt template or examples below to test the skill.
Adapt the skill to your specific use case and workflow.
Build a production-ready AI agent using LangGraph for [USE_CASE]. Follow the LangGraph Developer Navigator framework to: 1) Design a stateful workflow with [COMPONENTS], 2) Integrate [TOOLS/APIs] using official documentation, 3) Implement error handling and observability with [METRICS/TRACES], and 4) Package the agent for deployment. Use the official LangGraph docs at https://langchain-ai.github.io/langgraph/ as your primary reference. Return a complete implementation with comments explaining each decision.
### Production-Ready AI Agent for Customer Support Triage
**Workflow Design:**
The agent uses a stateful graph with three nodes: `router`, `classifier`, and `resolver`. The `router` node analyzes incoming customer queries using a lightweight LLM call to determine intent (billing, technical, product feedback). The `classifier` node enriches the state with metadata (priority, sentiment score) using a local Hugging Face model (`distilbert-base-uncased-emotion`). The `resolver` node dispatches to one of three subgraphs:
- **Billing:** Calls Stripe API via `stripe-python==5.24.0` (official SDK) to fetch invoice history and generate a summary.
- **Technical:** Queries a local vector store (FAISS) built from official product documentation (v2.1.3) using `langchain-community==0.0.36`.
- **Feedback:** Stores the query in a PostgreSQL table (`customer_feedback`) with a timestamp and sentiment score.
**Error Handling & Observability:**
- All nodes log to OpenTelemetry with trace IDs propagated across the graph.
- Failed API calls (e.g., Stripe rate limits) trigger a retry with exponential backoff and alert via Slack webhook (using `slack_sdk==3.21.0`).
- Metrics are exposed via Prometheus (`langgraph_metrics_total{node="resolver",status="success"}`).
**Deployment:**
The agent is packaged as a Docker container with a FastAPI endpoint (`/v1/triage`) and a health check (`/health`). Environment variables are validated at startup using `pydantic==2.6.4`. The container includes a `langgraph` CLI tool for local testing:
```bash
langgraph test --config ./config.yaml --input ./test_queries.jsonl
```
**State Schema:**
```python
typedef State(TypedDict):
query: str
intent: Literal["billing", "technical", "feedback"]
priority: int # 1-5
sentiment: float # -1 to 1
resolved: bool
trace_id: str
```
**Why This Works:**
- **Reliability:** Official SDKs and local documentation reduce dependency on external APIs.
- **Security:** No external LLM calls for sensitive data (billing queries are resolved locally).
- **Observability:** Traces and metrics enable debugging in production without guesswork.
- **Scalability:** The subgraph pattern allows adding new intents (e.g., "refunds") without modifying core logic.
**Next Steps:**
1. Deploy the agent to a Kubernetes cluster with 2 replicas and horizontal pod autoscaling.
2. Monitor the `langgraph_metrics_total` dashboard for resolver latency spikes.
3. Add a `feedback_analysis` subgraph to auto-generate monthly reports using `pandas==2.2.1`.Framework for building applications with LLMs
AI-powered code editor by Codeium
Auto-transcribe meetings and generate action items
The AI Code Editor for productive developers
Enterprise workflow automation and service management platform
Automate your spreadsheet tasks with AI power
Take a free 3-minute scan and get personalized AI skill recommendations.
Take free scan