Agent Hub Platform

🚀 Overview

Agent Hub is an enterprise-grade AI orchestration platform that transforms how developers and DevOps engineers interact with their toolchain. Built on the cutting-edge Model Context Protocol (MCP), it provides intelligent automation through specialized AI agents, seamlessly integrating with GitHub, Azure, security tools, and data processing services.

🎯 Key Value Propositions

• 🤖 Multi-Agent Intelligence: 9 specialized AI agents working in concert
• ⚡ Developer Velocity: Reduce context switching by 80% with unified interface
• 🔒 Enterprise Security: Built-in vulnerability scanning and compliance monitoring
• 🌐 Cloud-Native: Azure OpenAI integration with enterprise authentication
• 📈 Scalable Architecture: Microservices design supporting 50+ integrated tools

🏗️ System Architecture

graph TB
    subgraph "Frontend Layer"
        A[Agent Hub Frontend<br/>Angular 20+ • TypeScript<br/>Real-time Chat Interface]
    end
    
    subgraph "API Gateway Layer"
        B[Agent Hub API<br/>FastAPI • Python 3.12+<br/>Multi-Agent Orchestration]
    end
    
    subgraph "AI Service Layer"
        C[Azure OpenAI<br/>GPT-4o • LlamaIndex<br/>RAG Capabilities]
    end
    
    subgraph "Agent Ecosystem"
        D[GitHub Agent<br/>Repository Management]
        E[Azure Agent<br/>Cloud Operations] 
        F[Security Agent<br/>Vulnerability Scanning]
        G[PDF Agent<br/>Document Processing]
        H[Scraper Agent<br/>Web Data Extraction]
        I[Chart Agent<br/>Data Visualization]
    end
    
    subgraph "MCP Protocol Layer"
        J[MCP Tools Server<br/>FastMCP • 50+ Tools<br/>Extensible Architecture]
    end
    
    subgraph "External Integrations"
        K[GitHub API<br/>Repositories • Actions]
        L[Azure Services<br/>Resource Management]
        M[Snyk Security<br/>Vulnerability Database]
        N[External APIs<br/>Third-party Services]
    end
    
    A --> B
    B --> C
    B --> D
    B --> E
    B --> F
    B --> G
    B --> H
    B --> I
    D --> J
    E --> J
    F --> J
    G --> J
    H --> J
    I --> J
    J --> K
    J --> L
    J --> M
    J --> N
    
    style A fill:#e1f5fe
    style B fill:#f3e5f5
    style C fill:#fff3e0
    style J fill:#e8f5e8

🔄 Agent Orchestration Flow

graph TB
    A[User Query] --> B{Query Analysis}
    B --> C[Agent Selection Engine]
    C --> D[Dynamic Tool Composition]
    D --> E[LLM Processing]
    E --> F[Tool Execution]
    F --> G[Response Synthesis]
    G --> H[User Response]
    
    subgraph "Smart Agent Selection"f
        I[GitHub Keywords → GitHub Agent]
        J[Security Keywords → Security Agent]
        K[Cloud Keywords → Azure Agent]
        L[Document Keywords → PDF Agent]
    end
    
    C --> I
    C --> J
    C --> K
    C --> L
    
    style A fill:#e3f2fd
    style H fill:#e8f5e8
    style C fill:#fff3e0

💼 Component Overview

🤖 AI Agent Ecosystem

graph LR
    A[GitHub Agent] --> B[Repository Operations]
    A --> C[Issue Management] 
    A --> D[PR Automation]
    A --> E[Actions Integration]
    
    B --> B1[Clone/Fork]
    B --> B2[Branch Management]
    C --> C1[Create/Update Issues]
    C --> C2[Label Management]
    D --> D1[Review Automation]
    D --> D2[Merge Strategies]
    E --> E1[Workflow Triggers]
    E --> E2[Status Monitoring]

graph LR
    A[Azure Agent] --> B[Resource Management]
    A --> C[Service Principal Auth]
    A --> D[Infrastructure as Code]
    A --> E[Monitoring & Analytics]
    
    B --> B1[VM/Container Management]
    B --> B2[Storage Operations]
    C --> C1[Secure Authentication]
    C --> C2[Role-Based Access]
    D --> D1[ARM Templates]
    D --> D2[Terraform Integration]
    E --> E1[Cost Optimization]
    E --> E2[Performance Metrics]

graph LR
    A[Security Agent] --> B[Web Security]
    A --> C[Vulnerability Scanning]
    A --> D[Compliance Monitoring]
    A --> E[Threat Intelligence]
    
    B --> B1[SSL/TLS Analysis]
    B --> B2[Header Security]
    C --> C1[Dependency Scanning]
    C --> C2[Code Analysis]
    D --> D1[OWASP Compliance]
    D --> D2[Industry Standards]
    E --> E1[Risk Assessment]
    E --> E2[Remediation Plans]

📊 Platform Metrics & Performance

📋 Prerequisites

• Node.js 18+ (for frontend)
• Python 3.12+ (for backend and MCP server)
• Angular CLI 20.1.5+
• uv (recommended Python package manager) or pip
• Azure OpenAI resource with deployed model
• Docker (optional, for containerized deployment)

🚀 Quick Start

1. Clone the Repository

git clone <repository-url>
cd mb-mcp-agent

2. Environment Configuration

Create .env files for each component:

Agent Hub API (.env)

# Copy the example environment file
cp .env.example agent-hub-api/.env

# Edit with your Azure OpenAI credentials
cat > agent-hub-api/.env << EOF
AZURE_OPENAI_API_KEY=your-azure-openai-key
AZURE_OPENAI_ENDPOINT=https://genai-nexus.int.api.corpinter.net/apikey/
AZURE_OPENAI_DEPLOYMENT=gpt-4o
AZURE_OPENAI_API_VERSION=2024-10-21
EOF

MCP Tools Server (.env) - Optional for Authentication

cat > mcp-tools-server/.env << EOF
MCP_AUTH_ENABLED=true
MCP_AUTH_METHOD=bearer
MCP_PUBLIC_KEY=keys/public.pem
MCP_TOKEN_ISSUER=local-auth
MCP_TOKEN_AUDIENCE=fastmcp-tools
MCP_REQUIRED_SCOPES=read
EOF

3. Installation & Setup

Install All Components

# Frontend (Agent Hub)
cd agent-hub
npm install
cd ..

# Backend API
cd agent-hub-api
uv venv
source .venv/bin/activate  # or .venv\Scripts\activate on Windows
uv sync
cd ..

# MCP Tools Server
cd mcp-tools-server
uv venv
source .venv/bin/activate  # or .venv\Scripts\activate on Windows
uv sync
cd ..

4. Run the Platform

Option A: Development Mode (Recommended)

Start each component in separate terminals:

# Terminal 1: MCP Tools Server
cd mcp-tools-server
source .venv/bin/activate
uv run python main.py
# Server running on http://localhost:3001

# Terminal 2: Agent Hub API
cd agent-hub-api
source .venv/bin/activate
uvicorn app.main:app --reload --port 8000
# API running on http://localhost:8000

# Terminal 3: Agent Hub Frontend
cd agent-hub
ng serve
# Frontend running on http://localhost:4200

Option B: Docker Deployment

# Build and run MCP Tools Server
cd mcp-tools-server
docker build -t mcp-tools-server .
docker run --rm -p 3001:3001 mcp-tools-server

# Build and run Agent Hub API
cd ../agent-hub-api
docker build -t agent-hub-api .
docker run --rm -p 8000:8000 --env-file .env agent-hub-api

# Build and run Agent Hub Frontend
cd ../agent-hub
docker build -t agent-hub .
docker run --rm -p 4200:4200 agent-hub

🛠️ Development

Agent Hub (Frontend)

The Angular frontend provides the user interface for interacting with AI agents.

Key Commands

cd agent-hub

# Development server
ng serve

# Generate components
ng generate component component-name

# Build for production
ng build

# Run tests
ng test

# Run e2e tests
ng e2e

Project Structure

agent-hub/
├── src/
│   ├── app/           # Angular application modules
│   ├── environments/  # Environment configurations
│   └── model/         # TypeScript models
├── public/            # Static assets
└── angular.json       # Angular CLI configuration

Agent Hub API (Backend)

FastAPI backend that orchestrates AI agents and integrates with Azure OpenAI.

Key Features

• Multi-agent orchestration layer
• Azure OpenAI integration
• MCP (Model Context Protocol) support
• RESTful API endpoints
• Activity logging and file management

API Endpoints

• POST /chat - Main chat interface for AI interactions
• View full API documentation at http://localhost:8000/docs

Development Commands

cd agent-hub-api

# Run development server with auto-reload
uvicorn app.main:app --reload --port 8000

# Run tests
pytest

# Create admin user
python create_admin.py

MCP Tools Server

Extensible MCP server providing various utility tools and integrations.

Available Tool Categories

1. Sample Tools (sample/)

   • Word counting, text processing
   • Mathematical operations
   • Health checks

2. Security Tools (security_tools/)

   • HTTP header analysis
   • SSL/TLS configuration analysis
   • DNS security assessment
   • Comprehensive security scanning

3. PDF Tools (pdf_tools/)

   • Text extraction
   • Metadata retrieval
   • Page extraction
   • Content searching

4. Web Scraper Tools (web_scraper_tools/)

   • URL content scraping
   • Metadata extraction
   • Link extraction
   • Content parsing

Development Commands

cd mcp-tools-server

# Run the MCP server
uv run python main.py

# Generate authentication token
uv run python auth/token_generator.py

# Run specific tool server
uv run python -m tools.sample.server

Adding New Tools

1. Create a new tool directory (e.g., my_tool/)
2. Implement MCP tools using @mcp.tool()
3. Register in main.py
4. Optional: Add script entry in pyproject.toml

🔐 Authentication & Security

MCP Tools Server Authentication

The MCP Tools Server supports bearer token authentication:

1. Enable authentication in .env:

MCP_AUTH_ENABLED=true
MCP_AUTH_METHOD=bearer

2. Generate tokens:

cd mcp-tools-server
uv run python auth/token_generator.py

3. Use token in requests:

Authorization: Bearer <your-jwt-token>

📊 Monitoring & Logging

• Agent Hub API: Logs stored in agent-hub-api/logs/
• MCP Tools Server: Configurable logging with Rich console output
• Activity Tracking: Built-in activity logging for API operations

🧪 Testing

Run All Tests

# Frontend tests
cd agent-hub && ng test

# Backend tests
cd agent-hub-api && pytest

# MCP Tools tests
cd mcp-tools-server && pytest tests/

📦 Production Deployment

GitHub Actions CI/CD Pipeline

This repository includes a comprehensive CI/CD pipeline via GitHub Actions that:

1. Runs code quality checks and security scans
2. Builds and tests all services
3. Creates Docker images for each service
4. Pushes images to GitHub Container Registry (GHCR)
5. Provides deployment notifications

The pipeline is defined in .github/workflows/ci-cd.yml (in the repository root).

Deployment Options

Option 1: Using Pre-built Images (Recommended)

Follow the detailed deployment guide in DEPLOYMENT.md for step-by-step instructions.

Option 2: Automated Deployment Script

For production deployments to remote servers, you can use the provided deploy.sh script:

# Copy and configure environment file
cp .env.prod.example .env.prod
# Edit .env.prod with your production configuration

# Run deployment
./deploy.sh --host your-server.com --user deploy-user

Option 3: Docker Compose

Use the provided docker-compose.yml for orchestrated deployment:

version: '3.8'

services:
  # MCP Tools Server
  mcp-tools-server:
    build:
      context: ./mcp-tools-server
      dockerfile: Dockerfile
    image: mcp-tools-server:latest
    container_name: mcp-tools-server
    ports:
      - "3001:3001"
    networks:
      - agent-hub-network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3001/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

  # Agent Hub API
  agent-hub-api:
    build:
      context: ./agent-hub-api
      dockerfile: Dockerfile
    image: agent-hub-api:latest
    container_name: agent-hub-api
    ports:
      - "8000:8000"
    environment:
      - MCP_TOOLS_SERVER_URL=http://mcp-tools-server:3001
    env_file:
      - .env
    networks:
      - agent-hub-network
    depends_on:
      mcp-tools-server:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

  # Agent Hub Frontend
  agent-hub:
    build:
      context: ./agent-hub
      dockerfile: Dockerfile
    image: agent-hub:latest
    container_name: agent-hub
    ports:
      - "4200:80"
    networks:
      - agent-hub-network
    depends_on:
      agent-hub-api:
        condition: service_healthy
    # Environment variables for Angular at build time
    environment:
      - API_BASE_URL=/api

networks:
  agent-hub-network:
    driver: bridge

Environment Variables Checklist

• ✅ Azure OpenAI credentials configured
• ✅ Database connections established
• ✅ Authentication tokens generated
• ✅ CORS settings configured
• ✅ Production build optimizations enabled

🤝 Contributing

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

📚 Additional Resources

Documentation

• Angular CLI Reference
• FastAPI Documentation
• Model Context Protocol
• Azure OpenAI Service

Component-Specific READMEs

• Agent Hub Frontend
• Agent Hub API
• MCP Tools Server

📄 License

MIT License - see individual component directories for specific license details.

🆘 Support & Troubleshooting

Common Issues

1. Port Conflicts: Ensure ports 3001, 8000, and 4200 are available
2. Python Environment: Use Python 3.12+ and activate virtual environments
3. Azure OpenAI: Verify API keys and endpoint configurations
4. CORS Issues: Check backend CORS settings for frontend communication

Getting Help

• Open an issue on the GitHub repository
• Check component-specific READMEs for detailed troubleshooting
• Review logs in respective logs/ directories

🌟 Platform Capabilities

🎯 Technical Excellence

🏗️ Architectural Patterns

graph TB
    subgraph "Design Patterns"
        A[Factory Pattern<br/>Agent Creation]
        B[Observer Pattern<br/>Event Handling]
        C[Strategy Pattern<br/>Tool Selection]
        D[Decorator Pattern<br/>Middleware Chain]
    end
    
    subgraph "Enterprise Patterns"
        E[API Gateway<br/>Request Routing]
        F[Circuit Breaker<br/>Fault Tolerance]
        G[Bulkhead<br/>Resource Isolation]
        H[CQRS<br/>Command Query Separation]
    end
    
    A --> E
    B --> F
    C --> G
    D --> H
    
    style A fill:#e3f2fd
    style E fill:#f3e5f5