MCP Server with Gemini AI Integration

This project implements a Multi-Component Platform (MCP) server with Gemini AI integration, allowing users to perform various mathematical operations and complex tasks through natural language commands.

Features

- Mathematical Operations
- Basic arithmetic (add, subtract, multiply, divide)
- Advanced math (power, square root, cube root)
- Special functions (factorial, log, trigonometric functions)
- List operations (sum of list, exponential sum)

- String Processing
- Convert strings to ASCII values
- Process character arrays

- Keynote Integration
- Open Keynote application
- Draw rectangles with custom dimensions
- Add text to shapes

- AI-Powered Task Execution
- Natural language processing using Gemini AI
- Iterative problem solving
- Automatic tool selection based on user queries

Prerequisites

- Python 3.8 or higher
- Google Gemini API key
- macOS (for Keynote integration)

Installation

1. Clone the repository:

git clone <repository-url>

cd <repository-name>

2. Create and activate a virtual environment:

python -m venv venv

source venv/bin/activate  # On Windows: venv\Scripts\activate

3. Install dependencies:

pip install -r requirements.txt

4. Create a .env file in the project root and add your Gemini API key:

GEMINI_API_KEY=your_api_key_here

Project Structure

- mcp_server.py: Contains the MCP server implementation and tool definitions
- talk2mcp.py: Client application that interfaces with the MCP server and Gemini AI
- .env: Configuration file for API keys
- requirements.txt: Project dependencies

Usage

You can start the application in two ways:

Option 1: Start Server and Client Separately

1. Start the MCP server in one terminal:

python mcp_server.py

2. In another terminal, run the client application:

python talk2mcp.py

Option 2: Start Client Only (Recommended)

The client application can automatically start the server if it's not already running. Simply run:

python talk2mcp.py

The client will:
1. Check if the server is running
2. Start the server if needed
3. Establish connection automatically
4. Prompt for your query

Using the Application

1. Enter your query when prompted. Examples: - "Add 5 and 3" - "Find the ASCII values of characters in INDIA" - "Start keynote app and draw a rectangle of size 300x400" - "Calculate the factorial of 5"

2. Type 'exit' to quit the application.

Note: When using Option 2, the server will automatically shut down when you exit the client application.

Available Tools

The system provides the following tools:

1. Mathematical Tools
- add(a: int, b: int): Add two numbers
- subtract(a: int, b: int): Subtract two numbers
- multiply(a: int, b: int): Multiply two numbers
- divide(a: int, b: int): Divide two numbers
- power(a: int, b: int): Calculate power
- sqrt(a: int): Calculate square root
- cbrt(a: int): Calculate cube root
- factorial(a: int): Calculate factorial
- log(a: int): Calculate logarithm
- sin(a: int), cos(a: int), tan(a: int): Trigonometric functions

2. String Processing Tools
- strings_to_chars_to_int(string: str): Convert string to ASCII values
- int_list_to_exponential_sum(int_list: list): Calculate sum of exponentials

3. Keynote Tools
- open_keynote(): Open Keynote application
- draw_rectangle_in_keynote(shapeWidth: int, shapeHeight: int): Draw rectangle
- add_text_to_keynote_shape(text: str): Add text to shape

Demo

Watch a demo of the MCP Server with Gemini AI integration in action:

Click the image above to watch the demo video on YouTube.

Error Handling

The system includes comprehensive error handling:
- Timeout handling for AI responses
- Type conversion validation
- Tool availability checking
- Parameter validation

Debugging

Debug information is printed to the console, including:
- Tool execution details
- Parameter processing
- Result formatting
- Error messages and stack traces

Contributing

1. Fork the repository
2. Create a feature branch
3. Commit your changes
4. Push to the branch
5. Create a Pull Request

License

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

Acknowledgments

- Google Gemini AI for natural language processing capabilities
- MCP framework for tool management
- Python community for various libraries used in this project