Skip to content
Back to search

langgraph-ai

A comprehensive collection of LangGraph implementations, tutorials, and advanced AI workflows covering Agentic RAG systems, MCP (Model Context Protocol) development, and practical AI application patterns.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/piyushagni5--langgraph-ai/badge.svg)](/listings/piyushagni5--langgraph-ai)

HTML

<a href="/listings/piyushagni5--langgraph-ai"><img src="/api/listings/piyushagni5--langgraph-ai/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

Step 1: Clone the Repository

git clone https://github.com/piyushagni5/langgraph-ai.git
cd langgraph-ai

Step 2: Install UV Package Manager

If you haven't installed UV yet, install it using:

curl -LsSf https://astral.sh/uv/install.sh | sh

For Windows (PowerShell):

powershell -c "irm https://astral.sh/uv/install.ps1 | iex"

Step 3: Create Virtual Environment

Navigate to the specific project directory you want to work with. For example, to work with the Adaptive RAG system:

cd langgraph-cookbook/agentic-patterns

Create a virtual environment using UV:

uv venv --python 3.10

Step 4: Activate Virtual Environment

**On macOS/Linux:**

source .venv/bin/activate

**On Windows:**

.venv\Scripts\activate

Step 5: Install Dependencies

**Using UV (Recommended):**

uv pip install -r requirements.txt

**Using pip (Alternative):**

pip install -r requirements.txt

Step 6: Adding Virtual Environment to Jupyter Kernel

To use your UV virtual environment with Jupyter notebooks, you need to install ipykernel and register the environment as a kernel: **Install ipykernel in the virtual environment**:

   uv pip install ipykernel

**Register the virtual environment as a Jupyter kernel**:

   python -m ipykernel install --user --name=langgraph-ai --display-name="LangGraph AI"

When you open a notebook, you can select the "LangGraph AI" kernel from the kernel menu.

Step 7: Environment Configuration

Create a `.env` file in your project directory with the necessary API keys:

ANTHROPIC_API_KEY="your-anthropic-api-key"
# LANGCHAIN_API_KEY="your-langchain-api-key"  # optional
# LANGCHAIN_TRACING_V2=True                   # optional
# LANGCHAIN_PROJECT="multi-agent-swarm"       # optional

**Note**: The `LANGCHAIN_API_KEY` is required if you enable tracing with `LANGCHAIN_TRACING_V2=true`.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 177 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # LangGraph AI Repository
  2. A comprehensive collection of LangGraph implementations, tutorials, and advanced AI workflows covering Agentic RAG systems, MCP (Model Context Protocol) development, and practical AI application patterns.
  3. ## Overview
  4. This repository serves as a implementation guide for building sophisticated AI applications using LangGraph. It contains practical examples, tutorials, and production-ready implementations across multiple domains:
  5. - **Agentic RAG Systems**: Advanced retrieval-augmented generation with adaptive routing and self-correction mechanisms
  6. - **MCP Development**: Complete Model Context Protocol server and client implementations
  7. - **Workflow Patterns**: Orchestration patterns for complex AI workflows
  8. - **Human-in-the-Loop Systems**: Interactive AI systems with human oversight
  9. - **Advanced RAG Agents**: Sophisticated retrieval and generation systems
  10. ## Repository Structure
  11. ```
  12. langgraph-ai/
  13. ├── rag/
  14. │ ├── rag-from-scratch/
  15. │ │ └── 1_rag_overview.ipynb
  16. │ ├── rag-agents/
  17. │ │ ├── Building an Advanced RAG Agent.ipynb
  18. │ │ └── rag-as-tool-in-langgraph-agents.ipynb
  19. │ ├── agentic-rag/
  20. │ │ ├── agentic-rag-systems/
  21. │ │ │ └── building-adaptive-rag/
  22. │ │ └── agentic-workflow-pattern/
  23. │ │ ├── 1-prompting_chaining.ipynb
  24. │ │ ├── 2-routing.ipynb
  25. │ │ ├── 3-parallelization.ipynb
  26. │ │ ├── 4-orchestrator-worker.ipynb
  27. │ │ └── 5-Evaluator-optimizer.ipynb
  28. ├── mcp/
  29. │ ├── 01-build-your-own-server-client/
  30. │ ├── 02-build-mcp-client-with-multiple-server-support/
  31. │ ├── 03-build-mcp-server-client-using-sse/
  32. │ └── 04-build-streammable-http-mcp-client/
  33. ├── langgraph-cookbook/
  34. │ ├── human-in-the-loop/
  35. │ │ ├── 01-human-in-the-loop.ipynb
  36. │ │ ├── 02-human-in-the-loop.ipynb
  37. │ │ └── 03-human-in-the-loop.ipynb
  38. │ └── tool-calling -vs-react.ipynb
  39. ├── .gitignore
  40. ├── .gitmodules
  41. ├── README.md
  42. └── requirements.txt
  43. ```
  44. ## Prerequisites
  45. Before setting up this repository, ensure you have the following installed:
  46. - Python 3.10 or higher (depends on the project)
  47. - UV package manager (recommended) or pip
  48. - Git
  49. ## Installation and Setup
  50. ### Step 1: Clone the Repository
  51. ```bash
  52. git clone https://github.com/piyushagni5/langgraph-ai.git
  53. cd langgraph-ai
  54. ```
  55. ### Step 2: Install UV Package Manager
  56. If you haven't installed UV yet, install it using:
  57. ```bash
  58. curl -LsSf https://astral.sh/uv/install.sh | sh
  59. ```
  60. For Windows (PowerShell):
  61. ```powershell
  62. powershell -c "irm https://astral.sh/uv/install.ps1 | iex"
  63. ```
  64. ### Step 3: Create Virtual Environment
  65. Navigate to the specific project directory you want to work with. For example, to work with the Adaptive RAG system:
  66. ```bash
  67. cd langgraph-cookbook/agentic-patterns
  68. ```
  69. Create a virtual environment using UV:
  70. ```bash
  71. uv venv --python 3.10
  72. ```
  73. ### Step 4: Activate Virtual Environment
  74. **On macOS/Linux:**
  75. ```bash
  76. source .venv/bin/activate
  77. ```
  78. **On Windows:**
  79. ```bash
  80. .venv\Scripts\activate
  81. ```
  82. ### Step 5: Install Dependencies
  83. **Using UV (Recommended):**
  84. ```bash
  85. uv pip install -r requirements.txt
  86. ```
  87. **Using pip (Alternative):**
  88. ```bash
  89. pip install -r requirements.txt
  90. ```
  91. ### Step 6: Adding Virtual Environment to Jupyter Kernel
  92. To use your UV virtual environment with Jupyter notebooks, you need to install ipykernel and register the environment as a kernel:
  93. **Install ipykernel in the virtual environment**:
  94. ```bash
  95. uv pip install ipykernel
  96. ```
  97. **Register the virtual environment as a Jupyter kernel**:
  98. ```bash
  99. python -m ipykernel install --user --name=langgraph-ai --display-name="LangGraph AI"
  100. ```
  101. When you open a notebook, you can select the "LangGraph AI" kernel from the kernel menu.
  102. ### Step 7: Environment Configuration
  103. Create a `.env` file in your project directory with the necessary API keys:
  104. ```env
  105. ANTHROPIC_API_KEY="your-anthropic-api-key"
  106. # LANGCHAIN_API_KEY="your-langchain-api-key" # optional
  107. # LANGCHAIN_TRACING_V2=True # optional
  108. # LANGCHAIN_PROJECT="multi-agent-swarm" # optional
  109. ```
  110. **Note**: The `LANGCHAIN_API_KEY` is required if you enable tracing with `LANGCHAIN_TRACING_V2=true`.
  111. ## Running Projects
  112. ### Adaptive RAG System
  113. ```bash
  114. cd agentic-rag/agentic-rag-systems/building-adaptive-rag
  115. uv run main.py
  116. ```
  117. ### Running Tests
  118. ```bash
  119. uv run pytest . -s -v
  120. ```
  121. ## Contributing
  122. Contributions are welcome! Please feel free to submit pull requests or open issues for:
  123. - Bug fixes and improvements
  124. - New tutorial implementations
  125. - Documentation enhancements
  126. - Performance optimizations
  127. ## License
  128. This project is open source and available under the MIT License.
  129. ---
  130. **Note**: This repository contains multiple independent projects. Each project has its own requirements and setup instructions. Please refer to individual project README files for specific details.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.