A Python Code Auditor built using a Multi-Agent architecture and Model Context Protocol (MCP). The project analyzes Python source code by combining AST parsing, an orchestrator, MCP client-server communication, and multiple AI agents to generate code analysis reports through a Sequential LLM Pipeline.

---

Technologies Used

• Python
• Model Context Protocol (MCP)
• Abstract Syntax Tree (AST)
• Orchestrator
• Sequential LLM Pipeline
• AI Agents
• Groq API
• Radon
• Bandit

---

Project Structure

---

Project Workflow

Step 1 – Read Python Source Code

The File Reader reads a sample Python file and converts it into a string.

Step 2 – AST Parsing

The source code is parsed using Python's Abstract Syntax Tree (AST).

The AST parser extracts information such as:

• Functions
• Classes
• Imports
• Loops
• Conditional Statements
• Exception Handling Blocks

Instead of analyzing raw source code repeatedly, the agents use this AST summary as a structured representation of the program.

---

Step 3 – Orchestrator

The orchestrator decides which analysis tool (agent) should be executed.

This acts as the decision-making component before invoking the MCP communication and initiating the Sequential LLM Pipeline.

---

Step 4 – MCP Communication

The project follows an MCP-based client-server architecture.

• The Client acts as a messenger.
• It requests the required tool from the MCP Server.
• The Server executes the requested tool.
• The result is returned back through the Client.

---

Step 5 – AI Agents

Each MCP tool contains a dedicated AI Agent.

Each agent performs one specific task.

The available agents are:

• Security Agent
• Quality Agent
• Complexity Agent
• Summary Agent

Each agent receives the AST information and performs only its assigned analysis.

Together, these agents form a Sequential LLM Pipeline, where each stage performs a dedicated analysis before passing the results to the next stage.

---

Step 6 – AI Model

Each agent sends its prompt to the configured LLM API (Groq).

The generated response is returned back through the following flow:

LLM API
   ↓
Agent
   ↓
Tool
   ↓
MCP Server
   ↓
MCP Client
   ↓
Orchestrator

This completes one stage of the Sequential LLM Pipeline, allowing each analysis to be generated independently and combined into the final report.

---

Analysis Performed

The project currently performs:

• Security Analysis
• Code Quality Analysis
• Complexity Analysis
• Final Summary Generation

---

Output

---

---

---

Tools Used

AST

Used to generate a structured representation of the Python code.

MCP

Provides client-server communication between the orchestrator and analysis tools.

Orchestrator

Determines which analysis tool or agent should be executed before starting the Sequential LLM Pipeline.

Bandit

Used for security-related code analysis.

Radon

Used for complexity analysis.

---

Execution Flow

Sample Python File
        │
        ▼
File Reader
        │
        ▼
AST Parser
        │
        ▼
Orchestrator
        │
        ▼
MCP Client
        │
        ▼
MCP Server
        │
        ▼
Security Tool
        │
        ▼
Security Agent
        │
        ▼
Quality Tool
        │
        ▼
Quality Agent
        │
        ▼
Complexity Tool
        │
        ▼
Complexity Agent
        │
        ▼
Summary Tool
        │
        ▼
Summary Agent
        │
        ▼
Groq API
        │
        ▼
Analysis Reports

This execution represents a Sequential LLM Pipeline, where each specialized agent performs its task and contributes to the final consolidated audit report.

---

Repository

The project demonstrates how AST parsing, MCP, an orchestrator, and a Sequential LLM Pipeline of specialized AI agents can be combined to analyze Python code and generate security, quality, complexity, and summary reports through a client-server architecture.