FastAPI + MCP + Gemini Integration

This project demonstrates how to integrate a FastAPI application with Google's Gemini AI using a simplified MCP (Model Context Protocol) server implementation.

🏗️ Architecture

• FastAPI App (app.py): A sample REST API with user management, task management, and dice rolling

• Simple MCP Server (simple_mcp_server.py): Simplified MCP server that exposes FastAPI endpoints as tools

• Gemini Integration (simple_gemini_integration.py): Connects Gemini AI with the MCP server

🚀 Features

FastAPI Application

• User management (CRUD operations)

• Task management with completion tracking

• Dice rolling functionality

• Health checks and statistics

• RESTful API endpoints

MCP Server Tools

• get_health_status(): Check application health

• get_app_info(): Get application information

• get_all_users(): Retrieve all users

• create_user(): Create new users

• get_user_by_id(): Get specific user

• get_all_tasks(): Retrieve all tasks

• create_task(): Create new tasks

• complete_task(): Mark tasks as completed

• roll_dice(): Roll dice with custom parameters

• get_app_statistics(): Get application statistics

• search_users_by_name(): Search users by name

• get_pending_tasks(): Get incomplete tasks

• get_completed_tasks(): Get completed tasks

📋 Prerequisites

• Python 3.8+

• Google Gemini API key (optional - demo works in simulation mode)

• Basic Python packages (fastapi, uvicorn, aiohttp, google-generativeai)

🛠️ Installation

1. Clone or download the project files

2. Install dependencies:

   pip install fastapi uvicorn aiohttp google-generativeai python-dotenv requests

3. Set up environment variables (optional): Create a .env file and add your Gemini API key:

   GEMINI_API_KEY=your_actual_api_key_here

   Note: The demo works without an API key in simulation mode.

4. Get a Gemini API key:

   • Visit Google AI Studio

   • Create a new API key

   • Add it to your .env file

🎯 Usage

0. Look for the video demo

You can look for the zip file in which screen recording is present. That includes a demo question and an answer.

1. Start the FastAPI Server

python app.py

The FastAPI server will run on http://localhost:8000

2. Test the FastAPI Endpoints

You can test the API directly:

# Health check
curl http://localhost:8000/health

# Get app info
curl http://localhost:8000/

# Create a user
curl -X POST "http://localhost:8000/users?name=John&email=john@example.com&age=30"

# Create a task
curl -X POST "http://localhost:8000/tasks?title=Learn%20FastMCP&description=Study%20FastMCP%20integration"

# Roll dice
curl "http://localhost:8000/dice/roll?sides=6&count=3"

3. Run the Gemini Integration

Demo Mode (Predefined Queries)

python simple_gemini_integration.py

Interactive Mode

python simple_gemini_integration.py --interactive

Automated Demo

python start_simple_demo.py

4. Example Gemini Queries

In interactive mode, you can ask questions like:

• "Check the health status of the FastAPI application"

• "Create a new user named 'Alice' with email 'alice@example.com' and age 25"

• "Create a task called 'Learn Python' with description 'Study Python programming'"

• "Roll 5 dice with 10 sides each"

• "Show me all users and get the application statistics"

• "Mark the first task as completed"

• "Show me all pending tasks"

🔧 Configuration

FastAPI Server

• Default port: 8000

• Host: 0.0.0.0 (accessible from all interfaces)

• Modify app.py to change these settings

MCP Server

• Connects to FastAPI server at http://localhost:8000

• Modify API_BASE_URL in mcp_server.py if needed

Gemini Integration

• Uses Gemini 2.0 Flash model

• Configure API key via environment variable

• Modify model settings in gemini_integration.py

📁 Project Structure

.
├── app.py                        # FastAPI application
├── simple_mcp_server.py         # Simplified MCP server with tools
├── simple_gemini_integration.py # Gemini + MCP integration
├── start_simple_demo.py         # Automated startup script
├── test_simple_integration.py   # Integration testing
├── requirements.txt             # Python dependencies
├── .gitignore                   # Git ignore file
└── README.md                    # This file

🧪 Testing

Test FastAPI Endpoints

# Start the server
python app.py

# In another terminal, test endpoints
curl http://localhost:8000/health
curl http://localhost:8000/users
curl http://localhost:8000/tasks

Test MCP Server

python simple_mcp_server.py

Test Gemini Integration

# Make sure FastAPI server is running
python app.py

# In another terminal, run integration
python simple_gemini_integration.py

Test Everything

python test_simple_integration.py

🔍 Troubleshooting

Common Issues

1. "Please set GEMINI_API_KEY environment variable"

   • Make sure you have a .env file with your API key

   • Check that the API key is valid

2. "Error connecting to MCP server"

   • Ensure the FastAPI server is running on port 8000

   • Check that all dependencies are installed

3. "ModuleNotFoundError"

   • Run pip install -r requirements.txt

   • Make sure you're using Python 3.8+

Debug Mode

To see more detailed error messages, you can modify the integration script to include more logging.

🚀 Next Steps

• Add more FastAPI endpoints

• Create additional MCP tools

• Implement authentication

• Add database persistence

• Create a web interface

• Deploy to cloud platforms

📚 Learn More

• FastAPI Documentation

• FastMCP Documentation

• Google Gemini API

• Model Context Protocol

🤝 Contributing

Feel free to submit issues and enhancement requests!

📄 License

This project is open source and available under the MIT License.