🤖 Agentic Engineering Playground

A comprehensive engineering playground demonstrating the evolution from basic LLM API calls to complex, autonomous Multi-Agent Systems.

This repository serves as a practical implementation of modern AI engineering concepts, including Tool Use (Function Calling), Retrieval-Augmented Generation (RAG), and State Machine Orchestration.

🧠 Core Technologies

• Frameworks: LangGraph (Enterprise State Machines), CrewAI (Multi-Agent Orchestration)
• Memory & RAG: ChromaDB (Vector Database)
• Models: Google Gemini API (gemini-2.5-flash, gemini-embedding-001)
• Observability: LangSmith (Tracing & Debugging)
• Infrastructure: Docker, VS Code DevContainers (Isolated reproducible environment)

🏗️ Project Architecture & Modules

The repository is structured to show the progression of Agentic AI capabilities:

1. agent.py (ReAct Loop & Tool Use): A custom-built autonomous loop where the LLM decides when to use a terminal execution tool, parses the output, and reflects on the result.
2. crew_demo.py (Multi-Agent Collaboration): A CrewAI implementation where multiple AI personas (Analyst & Writer) collaborate, delegate tasks, and use tools to generate technical documentation.
3. custom_graph.py (LangGraph State Machine): A deterministic, graph-based agent architecture providing strict control over the execution flow and tool routing, fully integrated with LangSmith for observability.
4. full_rag.py (Vector Memory & RAG): Implementation of semantic search using ChromaDB and Google Embeddings. Includes a Similarity Score Threshold to prevent LLM hallucinations when queried with out-of-context information.
5. forgejo_agent.py & webhook_server.py (Autonomous DevOps Agent): The capstone project of this playground. It features a full-cycle AI developer that:

• Listens to Webhooks: Uses FastAPI to receive real-time events from a self-hosted Forgejo (Git) server.
• Self-Healing & Coding: Automatically analyzes new Issues, writes Python code, and performs local execution tests before committing.
• Automated Management: Updates repository files and closes tasks autonomously upon successful completion.
• Resilience: Implements exponential backoff (Tenacity) to handle API rate limits.

🛠️ How to Run (Reproducible Environment)

This project uses a DevContainer to ensure a clean, isolated environment with Docker-outside-of-Docker (DooD) capabilities. You don't need to install Python or dependencies on your local machine.

1. Clone the repository.
2. Open the folder in VS Code (requires the Dev Containers extension).
3. Click "Reopen in Container" when prompted. The environment will build automatically.
4. Create a .env file in the root directory and add your API keys:

   GEMINI_API_KEY=your_google_api_key
   LANGCHAIN_TRACING_V2=true
   LANGCHAIN_API_KEY=your_langsmith_key
   LANGCHAIN_PROJECT="Agentic_Architecture_Lab"

5. Run any of the modules, e.g., python full_rag.py.

🎓 Inspiration & Acknowledgements

This repository is a self-directed engineering project. The architecture and learning path were heavily inspired by the syllabus of the "Multi-Agent Systems" course by RobotDreams. It represents a hands-on implementation of their theoretical concepts regarding LLM limitations, attention mechanisms, vector embeddings, and agentic orchestration.