End-to-End Agentic AI Automation Lab

by MDalamin5

83 stars

636 downloads

Not rated

GitHub Website

Other

About

This repository contains hands-on projects, code examples, and deployment workflows. Explore multi-agent systems, LangChain, LangGraph, AutoGen, CrewAI, RAG, MCP, automation with n8n, and scalable agent deployment using Docker, AWS, and BentoML.

Details

Author: MDalamin5
GitHub stars: 83
Downloads: 636
Categories: Other

- 24 modules spanning foundations, agentic frameworks, and full-stack products.
- Advanced agentic implementations with LangGraph, AutoGen, and MCP.
- Production RAG Pipelines including hybrid search, BM25, and LlamaParse.
- Zero-code orchestration using n8n and LangFlow.
- LLM fine-tuning with LoRA/Unsloth and deployment via vLLM.
- End-to-end projects: AI Interviewer, Applicant Tracking System, SynapseAI chatbot.

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name End-to-End Agentic AI Automation Lab

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "end-to-end agentic ai automation lab": {
            "End-to-End-Agentic-Ai-Automation-Lab": {
                "command": "python",
                "args": [
                    "-m",
                    "venv",
                    "venv"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "end-to-end agentic ai automation lab": {
            "End-to-End-Agentic-Ai-Automation-Lab": {
                "command": "python",
                "args": [
                    "-m",
                    "venv",
                    "venv"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "end-to-end agentic ai automation lab": {
            "End-to-End-Agentic-Ai-Automation-Lab": {
                "command": "python",
                "args": [
                    "-m",
                    "venv",
                    "venv"
                ]
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "end-to-end agentic ai automation lab": {
            "End-to-End-Agentic-Ai-Automation-Lab": {
                "command": "python",
                "args": [
                    "-m",
                    "venv",
                    "venv"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "end-to-end agentic ai automation lab": {
            "End-to-End-Agentic-Ai-Automation-Lab": {
                "command": "python",
                "args": [
                    "-m",
                    "venv",
                    "venv"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "end-to-end agentic ai automation lab": {
            "End-to-End-Agentic-Ai-Automation-Lab": {
                "command": "python",
                "args": [
                    "-m",
                    "venv",
                    "venv"
                ]
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "end-to-end agentic ai automation lab": {
            "End-to-End-Agentic-Ai-Automation-Lab": {
                "command": "python",
                "args": [
                    "-m",
                    "venv",
                    "venv"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "end-to-end agentic ai automation lab": {
            "End-to-End-Agentic-Ai-Automation-Lab": {
                "command": "python",
                "args": [
                    "-m",
                    "venv",
                    "venv"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "end-to-end agentic ai automation lab": {
            "End-to-End-Agentic-Ai-Automation-Lab": {
                "command": "python",
                "args": [
                    "-m",
                    "venv",
                    "venv"
                ]
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "end-to-end agentic ai automation lab": {
            "End-to-End-Agentic-Ai-Automation-Lab": {
                "command": "python",
                "args": [
                    "-m",
                    "venv",
                    "venv"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "end-to-end agentic ai automation lab": {
            "End-to-End-Agentic-Ai-Automation-Lab": {
                "command": "python",
                "args": [
                    "-m",
                    "venv",
                    "venv"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "end-to-end agentic ai automation lab": {
            "End-to-End-Agentic-Ai-Automation-Lab": {
                "command": "python",
                "args": [
                    "-m",
                    "venv",
                    "venv"
                ]
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "end-to-end agentic ai automation lab": {
            "End-to-End-Agentic-Ai-Automation-Lab": {
                "command": "python",
                "args": [
                    "-m",
                    "venv",
                    "venv"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "end-to-end agentic ai automation lab": {
            "End-to-End-Agentic-Ai-Automation-Lab": {
                "command": "python",
                "args": [
                    "-m",
                    "venv",
                    "venv"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "end-to-end agentic ai automation lab": {
            "End-to-End-Agentic-Ai-Automation-Lab": {
                "command": "python",
                "args": [
                    "-m",
                    "venv",
                    "venv"
                ]
            }
        }
    }
}

From the repository

Clone the repository, set up a Python 3.10+ virtual environment, navigate to a specific module folder, install its dependencies from requirements.txt, and configure a .env file with required API keys (e.g., OpenAI, Anthropic). Each module is self-contained and can be run independently.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "end-to-end agentic ai automation lab": {
            "End-to-End-Agentic-Ai-Automation-Lab": {
                "command": "python",
                "args": [
                    "-m",
                    "venv",
                    "venv"
                ]
            }
        }
    }
}

McpServers

{
    "End-to-End-Agentic-Ai-Automation-Lab": {
        "command": "python",
        "args": [
            "-m",
            "venv",
            "venv"
        ]
    }
}

🤖 End-to-End Agentic AI & Automation Lab

A comprehensive, production-grade repository for building, deploying, and managing intelligent AI agents, RAG pipelines, and automated workflows.

Overview •
Key Highlights •
Project Architecture •
Tech Stack •
Getting Started

</div>

---

📖 Overview

Welcome to the End-to-End Agentic AI Automation Lab. This repository is a massive, hands-on engineering playbook demonstrating how to transition from basic LLM API calls to complex, multi-agent autonomous systems and production-ready AI products.

Whether you are looking to build highly reliable Agentic workflows using LangGraph, orchestrate multi-agent collaboration via AutoGen, implement cutting-edge Model Context Protocol (MCP), or serve fine-tuned local models using vLLM and Unsloth, this repository has you covered.

---

🚀 Key Highlights

Advanced Agentic Frameworks: Deep dives into LangGraph (StateGraphs, subgraphs, memory, HITL) and AutoGen (RoundRobin, Swarm, custom tools).
Model Context Protocol (MCP): Industry-grade implementations of Anthropic's MCP for tool execution, web search, and Notion integration.
Production RAG Systems: Implementation of Hybrid Search, BM25, LlamaParse, Semantic Routing, and Long/Short-Term Memory (Mem0).
AI Workflow Automation: Zero-code/low-code multi-agent orchestration using n8n and LangFlow.
LLM Fine-Tuning & Serving: Hands-on pipelines for fine-tuning with LoRA/Unsloth and deploying high-throughput inference endpoints with vLLM.
End-to-End Products: Complete full-stack implementations of an AI Interviewer, a Production ATS, and SynapseAI (a stateful, persistent chatbot).

---

📂 Repository Modules & Projects

The lab is structured progressively. Click to expand each module to see the underlying projects:

<details>
<summary>1️⃣ Foundations & Data Ingestion (Modules 01 - 02)</summary>

01-Pydantic-Data-Validation: Data structuring, field validation, and structured LLM outputs.
02-LangChain-Basics: Embedding models, VectorDBs (FAISS, Pinecone), and basic Retrieval-Augmented Generation (RAG) scratchpads.
</details>

<details>
<summary>2️⃣ LangGraph & Workflow Orchestration (Modules 03 - 04, 13 - 14)</summary>

03-LangGraph-Introduction: StateGraphs, Agentic workstations, multi-tool calling.
04-LangGraph-Agentic-Workflows: Agentic RAG, Multi-Agent Supervisors, Human-in-the-Loop (HITL), and Corrective RAG (CRAG).
13-e2e-Deep-Agents: Observation, evaluation, and reliable LangGraph applications.
14-e2e-Ambient-Agent: Building background-running autonomous agents.
</details>

<details>
<summary>3️⃣ AutoGen Multi-Agent Systems (Modules 05 - 09)</summary>

05-Autogen-Introduction: Async capabilities, tools, and basic teams.
06-Autogen-HITL-and-Agentic-Orchestrator: Selector Group Chats, Docker code execution, and Graph-based AutoGen.
07-End-To-End-Projects-Autogen: GPT Analyzer (Modular architecture), AI Interviewer.
08-Advanced-Autogen-Team: Swarm logic and Society of Mind teams.
09-Autogen-RAG-and-Memory: Integrating mem0 for cross-session AutoGen memory.
</details>

<details>
<summary>4️⃣ Model Context Protocol (MCP) & n8n (Modules 10 - 12)</summary>

10-MCP-All-You-Need: Bridging AutoGen and LangChain with MCP. Lead collector, FireCrawl MCP, and Playwright MCP.
11-MCP-based-End-to-End-Products: Building fast, robust API backends utilizing MCP architectures via ngrok and FastAPI.
12-n8n: High-level automations. Chain of Agents, Social Media Content Generation, parallel agent logic, and Telegram bot integrations.
</details>

<details>
<summary>5️⃣ Production RAG & Guardrails (Modules 17, 19)</summary>

17-Guardrails-for-llm: Implementing NeMo Guardrails for secure and constrained LLM outputs.
19-Productions-RAG: Industry-practice RAG including LlamaParse, BM25/Hybrid Search, HyDE, chunking strategies, and Reranking pipelines.
</details>

<details>
<summary>6️⃣ LLM Fine-Tuning & Deployment (Modules 21 - 22)</summary>

21-LLM-Deployment-vLLM: Deploying models for high-throughput generation using vLLM and accessing via LangChain SDK.
22-LLM-FineTune-Deployment: Model fine-tuning using Unsloth, LoRA, HuggingFace Pipelines, and quantization setups for edge devices.
</details>

<details>
<summary>7️⃣ End-to-End Full-Stack Projects (Modules 18, 20, 23, 24)</summary>

18-e2e-chatbot-mem0-tools-HITL-MCP-RAG: A massive implementation of a fully-featured chatbot with long/short-term memory, PostgreSQL persistence, and streaming UI.
20-e2e-Productions-grade-ATS: End-to-end Applicant Tracking System backed by Alembic, SQLModel, and LangGraph.
23-e2e-multi-agent-plan-research-write-blog: A multi-agent writer architecture with a beautiful web frontend.
24-SynapseAI-parsitence-chatbot: A modern API-first chatbot backend via FastAPI with complex graph routing.
</details>

---

🛠️ Tech Stack & Tools

Core AI/ML:

Agentic & Orchestration:

-5B0000?style=for-the-badge)

Backend & Data:

---

⚙️ Getting Started

1. Clone the Repository

git clone https://github.com/MDalamin5/End-to-End-Agentic-Ai-Automation-Lab.git
cd End-to-End-Agentic-Ai-Automation-Lab

2. Set Up Virtual Environment

It is recommended to use conda or venv to manage dependencies.

python -m venv venv
source venv/bin/activate  # On Windows use: venv\Scripts\activate

3. Install Dependencies

Dependencies may vary per module. Navigate to the specific project folder and install the requirements:

cd 18-e2e-chatbot-mem0-tools-HITL-MCP-RAG
pip install -r requirements.txt

4. Environment Variables

Copy the .env.example file (if available in the module) to .env and add your API keys (OpenAI, Anthropic, HuggingFace, etc.):

OPENAI_API_KEY="your_api_key_here"
ANTHROPIC_API_KEY="your_api_key_here"
TAVILY_API_KEY="your_api_key_here"

---

🤝 Contributing

This repository is continuously evolving! Contributions, bug reports, and feature requests are highly welcome.

1. Fork the Project
2. Create your Feature Branch (git checkout -b feature/AmazingFeature)
3. Commit your Changes (git commit -m 'Add some AmazingFeature')
4. Push to the Branch (git push origin feature/AmazingFeature)
5. Open a Pull Request

---

📜 License & Connect

Distributed under the MIT License. See LICENSE for more information.

<div align="center">

Developed with 💡 by Md Al Amin

If you find this repository helpful, don't forget to ⭐ star it!

</div>

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

Claude Desktop / Cursor

McpServers

🤖 End-to-End Agentic AI & Automation Lab

📖 Overview

🚀 Key Highlights

📂 Repository Modules & Projects

🛠️ Tech Stack & Tools

⚙️ Getting Started

1. Clone the Repository

2. Set Up Virtual Environment

3. Install Dependencies

4. Environment Variables

🤝 Contributing

📜 License & Connect

Install

More like this

Sequential Thinking

Filesystem

EverArt

Google Drive

Reactive Resume

FastMCP v2 🚀