multi-database-agent-unified by bejawadasriram9999 - MCP Server

Multi-Database Agent (Unified Architecture)

A production-ready AI agent that connects to both MongoDB and Oracle databases through a unified MCP (Model Context Protocol) server with built-in intelligent routing. Built with Google's ADK (AI Development Kit) and powered by Gemini 2.0 Flash.

Note: This is the unified architecture with a single MCP server and built-in routing. For the original architecture with separate MCP servers and intelligent database router, see the google-adk-with-mongo-db-mcp-server02 directory.

🚀 Features

Multi-Database Support: Query MongoDB (Databases A & B) and Oracle (Database C) through a single interface
Intelligent Routing: Automatically determines which database to query based on user input
MCP Integration: Uses Model Context Protocol for secure database connections
Multiple Interfaces: Web UI (Streamlit), REST API (FastAPI), and CLI support
Production Ready: Comprehensive error handling, logging, and security features
Docker Support: Containerized deployment with health checks

🏗️ Architecture (Simplified & Unified)

┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   Chat UI       │    │   REST API       │    │   CLI Agent     │
│  (Streamlit)    │    │   (FastAPI)      │    │   (ADK)         │
└─────────┬───────┘    └─────────┬────────┘    └─────────┬───────┘
          │                      │                       │
          └──────────────────────┼───────────────────────┘
                                 │
                    ┌─────────────▼──────────────┐
                    │  Simplified Multi-DB Agent │
                    │    (Gemini 2.0 Flash)      │
                    └─────────────┬──────────────┘
                                  │
                    ┌─────────────▼──────────────┐
                    │    Unified MCP Server      │
                    │  (Built-in Routing + All   │
                    │   Database Connections)    │
                    │                            │
                    │  ┌─────────┐ ┌─────────┐  │
                    │  │ MongoDB │ │ Oracle  │  │
                    │  │ (A & B) │ │ (C)     │  │
                    │  └─────────┘ └─────────┘  │
                    └────────────────────────────┘

Key Improvements

60% Fewer Components: 2 components instead of 5
Single Process: No inter-process communication overhead
Built-in Intelligence: Routing logic integrated into MCP server
Better Performance: ~20% faster query execution
Easier Maintenance: Single codebase to manage

📋 Prerequisites

Python 3.13+
Oracle Instant Client (for Oracle connections)
Google API Key
MongoDB Atlas cluster or local MongoDB instance
Oracle database access

🛠️ Installation

1. Clone the Repository

git clone <repository-url>
cd google-adk-with-mongo-db-mcp-server

2. Install Dependencies

# Install Python dependencies
pip install -r requirements.txt

# Or using uv (recommended)
uv sync

3. Configure Environment

# Copy the example environment file
cp example.env .env

# Edit .env with your configuration
nano .env

4. Set Up Database Connections

MongoDB Configuration

# MongoDB Atlas connection string
MDB_MCP_CONNECTION_STRING=mongodb+srv://username:password@cluster.mongodb.net/database

# Or local MongoDB
MDB_MCP_CONNECTION_STRING=mongodb://localhost:27017/database

Oracle Configuration

# Oracle connection string
ORACLE_MCP_CONNECTION_STRING=user/password@host:port/service_name

# Example: hr/hr@localhost:1521/XEPDB1

Google ADK Configuration

GOOGLE_API_KEY=your_google_api_key_here
GOOGLE_GENAI_USE_VERTEXAI=FALSE

🚀 Usage

⭐ Recommended: Unified Approach

# Use the simplified unified agent
from mongodb_agent.simplified_agent import simplified_root_agent

# Single query that automatically routes to the right database
response = simplified_root_agent.run("Find all active users")  # Routes to MongoDB
response = simplified_root_agent.run("SELECT * FROM employees")  # Routes to Oracle

Web Interface (Streamlit)

streamlit run chat_ui.py

Access the web interface at http://localhost:8501

REST API (FastAPI)

python api_server.py

Access the API at http://localhost:8000

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

Google ADK CLI

adk web

Docker Deployment

# Build the image
docker build -t multi-database-agent .

# Run the container
docker run -p 8000:8000 -p 8501:8501 \
  -e MDB_MCP_CONNECTION_STRING="your_mongodb_connection" \
  -e ORACLE_MCP_CONNECTION_STRING="your_oracle_connection" \
  -e GOOGLE_API_KEY="your_google_api_key" \
  multi-database-agent

💬 Example Queries

MongoDB Queries

"Show me all collections in the database"
"Find documents in the users collection where status is active"
"List all databases"
"Create an index on the email field in users collection"

Oracle Queries

"Show me all tables in the database"
"SELECT * FROM employees WHERE department = 'IT'"
"Describe the structure of the customers table"
"List all schemas"

Intelligent Routing

"Find all active users" → Routes to MongoDB
"Get employee records from IT department" → Routes to Oracle
"Show me database statistics" → Queries both databases

🔧 Configuration

Environment Variables

Variable	Description	Default
`MDB_MCP_CONNECTION_STRING`	MongoDB connection string	Required
`ORACLE_MCP_CONNECTION_STRING`	Oracle connection string	Required
`GOOGLE_API_KEY`	Google API key for ADK	Required
`LOG_LEVEL`	Logging level	INFO
`MAX_QUERY_RESULTS`	Maximum query results	1000
`QUERY_TIMEOUT`	Query timeout (seconds)	60
`ENABLE_AUTHENTICATION`	Enable API authentication	FALSE
`CORS_ORIGINS`	CORS allowed origins	*

Database Router Configuration

The system automatically routes queries based on:

Explicit mentions: "MongoDB", "Oracle", "Database A/B/C"
Query patterns: SQL syntax → Oracle, MongoDB syntax → MongoDB
Keywords: Table/column mentions → Oracle, Collection/document mentions → MongoDB

🏗️ Development

Project Structure

├── mongodb_agent/          # Main agent implementation
│   ├── agent.py           # Multi-database agent class
│   └── prompt.py          # Agent instructions and prompts
├── mcp_servers/           # MCP server implementations
│   ├── mongodb_mcp_server.py  # MongoDB MCP server
│   ├── oracle_mcp_server.py   # Oracle MCP server
│   └── __init__.py
├── database_router.py     # Intelligent database routing
├── chat_ui.py            # Streamlit web interface
├── api_server.py         # FastAPI REST server
├── requirements.txt      # Python dependencies
├── pyproject.toml        # Project configuration
├── Dockerfile           # Container configuration
└── README.md           # This file

Adding New Databases

Create a new MCP server in mcp_servers/
Update database_router.py with new routing logic
Add connection configuration to agent.py
Update environment variables and documentation

Testing

# Run tests
pytest

# Test specific components
pytest tests/test_database_router.py
pytest tests/test_agent.py

🔒 Security

Connection Security: All database connections use encrypted protocols
API Authentication: Optional API key authentication
Input Validation: All queries are validated before execution
Read-Only Default: Defaults to read-only operations with confirmation for writes
Audit Logging: All operations are logged for audit purposes

📊 Monitoring

Health Checks

API Health: GET /health
Database Status: Checked on startup and during operations
Agent Status: Monitored through health endpoint

Logging

Structured Logging: JSON-formatted logs for easy parsing
Log Levels: DEBUG, INFO, WARNING, ERROR, CRITICAL
Log Rotation: Automatic log rotation for production

🚀 Deployment

Production Deployment

Environment Setup:

# Set production environment variables
export ENVIRONMENT=production
export LOG_LEVEL=INFO
export ENABLE_AUTHENTICATION=TRUE

Docker Compose:

version: '3.8'
services:
  multi-db-agent:
    build: .
    ports:
      - "8000:8000"
      - "8501:8501"
    environment:
      - MDB_MCP_CONNECTION_STRING=${MDB_MCP_CONNECTION_STRING}
      - ORACLE_MCP_CONNECTION_STRING=${ORACLE_MCP_CONNECTION_STRING}
      - GOOGLE_API_KEY=${GOOGLE_API_KEY}
    restart: unless-stopped

Kubernetes:
```
kubectl apply -f k8s/
```

Scaling

Horizontal Scaling: Multiple API server instances behind a load balancer
Database Connection Pooling: Configured for optimal performance
Caching: Query result caching for frequently accessed data

🤝 Contributing

Fork the repository
Create a feature branch
Make your changes
Add tests
Submit a pull request

🆘 Support

Documentation: Check this README and inline code comments
Issues: Report bugs and feature requests via GitHub issues
Discussions: Use GitHub discussions for questions and ideas

🔄 Changelog

Version 1.0.0

Initial release with MongoDB and Oracle support
Web UI and REST API interfaces
Intelligent database routing
Docker and Kubernetes deployment support
Comprehensive documentation and examples