Enterprise AI Assistant Platform

A comprehensive GenAI platform demonstrating enterprise-level AI capabilities including multi-agent workflows, RAG systems, knowledge graphs, and MLOps integration.

🚀 Features

🤖 Multi-Agent AI System

Research Agent: Intelligent information gathering and web research
Data Analysis Agent: Advanced data processing and analytics
Content Generation Agent: AI-powered content creation and documentation
Crew Manager: Orchestrates multi-agent workflows using CrewAI

📚 RAG (Retrieval Augmented Generation)

Vector Store Integration: ChromaDB and Pinecone support
Document Processing: PDF, Word, and text document ingestion
Semantic Search: Advanced similarity search capabilities
Context-Aware Generation: LLM responses enhanced with retrieved knowledge

🕸️ Knowledge Graph System

Neo4j Integration: Graph database for complex relationships
Entity Recognition: Automatic extraction of entities and relationships
Graph Analytics: Advanced querying and relationship analysis
Knowledge Discovery: Intelligent insights from connected data

🔧 LLM Provider Management

Multi-Provider Support: OpenAI, Anthropic, Google AI integration
Provider Abstraction: Unified interface for different LLM APIs
Load Balancing: Intelligent routing across providers
Fallback Mechanisms: Automatic failover for reliability

📊 MLOps & Monitoring

MLflow Integration: Experiment tracking and model management
Prometheus Metrics: System performance monitoring
Health Checks: Comprehensive system health monitoring
Logging: Structured logging with correlation IDs

🏗️ Architecture

enterprise-ai-assistant-platform/
├── agents/                     # Multi-agent AI components
│   ├── research_agent.py      # Information gathering agent
│   ├── data_analysis_agent.py # Data processing agent
│   ├── content_generation_agent.py # Content creation agent
│   └── crew_manager.py        # Multi-agent orchestration
├── api/                        # FastAPI routes and endpoints
│   └── routes/                 # API route definitions
│       ├── agents.py          # Agent interaction endpoints
│       ├── rag.py             # RAG system endpoints
│       ├── knowledge_graph.py # Knowledge graph endpoints
│       └── health.py          # Health check endpoints
├── core/                       # Core system components
│   ├── config.py              # Configuration management
│   └── logging.py             # Structured logging setup
├── knowledge_graph/            # Knowledge graph implementation
│   ├── knowledge_graph_system.py # Graph operations
│   └── neo4j_manager.py       # Neo4j database management
├── llm_providers/             # LLM provider abstractions
│   └── provider_manager.py    # Multi-provider management
├── mlops/                     # MLOps and monitoring
│   └── monitoring.py          # Metrics and health checks
├── rag/                       # RAG system implementation
│   ├── rag_system.py          # Core RAG functionality
│   ├── vector_store.py        # Vector database management
│   └── document_processor.py  # Document ingestion
└── tests/                     # Comprehensive test suite
    ├── unit/                  # Unit tests
    ├── integration/           # Integration tests
    └── e2e/                   # End-to-end tests

🚦 Quick Start

Prerequisites

Python 3.11+
Docker & Docker Compose
Virtual environment (recommended)

Installation

Clone the repository

git clone <repository-url>
cd enterprise-ai-assistant-platform

Create virtual environment

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

Install dependencies

pip install -r requirements.txt
pip install -r requirements-test.txt

Configure environment

cp .env.example .env
# Edit .env with your API keys and configuration

Start infrastructure services

docker-compose up -d neo4j postgres chromadb mlflow

Run the application

python -m uvicorn main:app --host 0.0.0.0 --port 8000 --reload

The platform will be available at:

API: http://localhost:8000
API Documentation: http://localhost:8000/docs
ReDoc: http://localhost:8000/redoc
Health Check: http://localhost:8000/health

🔧 Configuration

Environment Variables

Create a .env file with the following configuration:

# Application Settings
DEBUG=true
LOG_LEVEL=INFO
API_HOST=0.0.0.0
API_PORT=8000

# LLM API Keys
OPENAI_API_KEY=your_openai_key
ANTHROPIC_API_KEY=your_anthropic_key
GOOGLE_API_KEY=your_google_key

# Vector Database
PINECONE_API_KEY=your_pinecone_key
PINECONE_ENVIRONMENT=your_pinecone_env
CHROMADB_HOST=localhost
CHROMADB_PORT=8000

# Knowledge Graph
NEO4J_URI=bolt://localhost:7687
NEO4J_USER=neo4j
NEO4J_PASSWORD=password

# MLOps
MLFLOW_TRACKING_URI=http://localhost:5000
PROMETHEUS_PORT=9090

Database Setup

The platform uses multiple databases:

Neo4j: Knowledge graph storage
ChromaDB: Vector embeddings
PostgreSQL: Structured data (via Docker)
MLflow: Model and experiment tracking

📖 API Documentation

Core Endpoints

Health Check

GET /health

Returns system health status and component availability.

Multi-Agent Workflows

POST /api/v1/agents/research
POST /api/v1/agents/analyze
POST /api/v1/agents/generate
POST /api/v1/agents/workflow

RAG System

POST /api/v1/rag/query
POST /api/v1/rag/ingest
GET /api/v1/rag/documents

Knowledge Graph

POST /api/v1/kg/query
POST /api/v1/kg/entities
GET /api/v1/kg/relationships

Example Usage

Research Agent

import httpx

response = httpx.post("http://localhost:8000/api/v1/agents/research", json={
    "task": "Research the latest trends in generative AI",
    "context": "Focus on enterprise applications",
    "parameters": {"depth": "comprehensive"}
})

RAG Query

response = httpx.post("http://localhost:8000/api/v1/rag/query", json={
    "query": "What are the benefits of multi-agent systems?",
    "top_k": 5,
    "filters": {"category": "ai-research"}
})

🧪 Testing

The platform includes a comprehensive test suite with unit, integration, and end-to-end tests.

Running Tests

# Run all tests
python -m pytest

# Run specific test categories
python -m pytest tests/unit/          # Unit tests
python -m pytest tests/integration/   # Integration tests
python -m pytest tests/e2e/          # End-to-end tests

# Run with coverage
python -m pytest --cov=. --cov-report=html

# Run specific test file
python -m pytest tests/unit/test_research_agent.py -v

Test Structure

Unit Tests: Test individual components in isolation
Integration Tests: Test component interactions
E2E Tests: Test complete workflows and API endpoints

Coverage reports are generated in htmlcov/ directory.

🚀 Deployment

Docker Deployment

Build the application

docker build -t enterprise-ai-platform .

Deploy with Docker Compose
```
docker-compose up -d
```

Production Considerations

Environment Variables: Secure API key management
Database Persistence: Configure volume mounts
Load Balancing: Use reverse proxy (nginx/traefik)
Monitoring: Enable Prometheus metrics collection
Logging: Configure centralized log aggregation
Security: Implement authentication and rate limiting

📊 Monitoring & Observability

Health Checks

Application health endpoint
Database connectivity checks
External service availability
Resource utilization monitoring

Metrics

Request/response metrics
Agent execution times
Database query performance
LLM provider response times

Logging

Structured JSON logging
Correlation ID tracking
Error aggregation
Performance profiling

🤝 Contributing

Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Make your changes
Add tests for new functionality
Ensure all tests pass (python -m pytest)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

Development Guidelines

Follow PEP 8 style guidelines
Write comprehensive tests
Update documentation
Use type hints
Add docstrings to all functions and classes

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🔗 Related Documentation

Testing Documentation - Comprehensive testing guide
API Reference - Interactive API documentation
Architecture Decision Records - Technical decisions and rationale

🆘 Support

For support and questions:

Create an issue in the GitHub repository
Check the FAQ
Review the troubleshooting guide

Built with ❤️ for demonstrating enterprise GenAI capabilities

Name		Name	Last commit message	Last commit date
Latest commit History 1 Commit
.github		.github
agents		agents
api		api
core		core
docs		docs
knowledge_graph		knowledge_graph
llm_providers		llm_providers
mlops		mlops
rag		rag
tests		tests
.env.example		.env.example
.gitignore		.gitignore
CHANGELOG.md		CHANGELOG.md
CONTRIBUTING.md		CONTRIBUTING.md
Dockerfile		Dockerfile
LICENSE		LICENSE
README.md		README.md
ULTRA_BUDGET_DEPLOYMENT.md		ULTRA_BUDGET_DEPLOYMENT.md
docker-compose.yml		docker-compose.yml
main.py		main.py
pyproject.toml		pyproject.toml
render.yaml		render.yaml
requirements-test.txt		requirements-test.txt
requirements.txt		requirements.txt
run_tests.py		run_tests.py
test.bat		test.bat

Folders and files

Latest commit

History

Repository files navigation