# Gemini MCP Chatbot

A simple MCP (Model Context Protocol) server over STDIO exposing calculator, file read, and file write tools for the Gemini CLI agent.

## Features

- Calculator
- File Read
- File Write

## Architecture at a Glance

```
Gemini CLI ──STDIO──> MCP Server (src/server.py) ──Tools──> Your Python Functions
```

The CLI launches the MCP server, streams requests over STDIO, and receives tool responses without needing sockets or REST.

## Project Tour

### `.gemini/settings.json`

```json
// filepath: f:\Workspace\AI Training\Gemini CLI\.gemini\settings.json
{
  "mcpServers": {
    "pythonTools": {
      "command": "poetry",
      "args": ["run", "python", "src/server.py"],
      "cwd": "",
      "env": {
        "MCP_PROXY_AUTH_TOKEN": "<MCP_PROXY_AUTH_TOKEN>"
      },
      "timeout": 15000
    }
  }
}
```

This configuration wires the CLI to spawn the MCP server through Poetry, injects the proxy token, and enforces a 15-second timeout.

> Note: When the server starts, it prints the configured token in the terminal so you can confirm the placeholder value.

### Python tools

The CLI mounts the MCP server defined in `src/server.py`, exposing calculator and file helpers for quick automation.

### MCP - Import

`FastMCP` class from `mcp` package can be used to instantly create mcp servers.

```python
# filepath: f:\Workspace\AI Training\Gemini CLI\src\server.py
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("demo")
```

### MCP decorators for tool registration

Decorators expose calculator and file utilities as discoverable MCP tools.  
Docstrings define parameters and return values for each tool so Gemini CLI can build the right schemas for invocation.

```python
# filepath: f:\Workspace\AI Training\Gemini CLI\src\server.py
@mcp.tool()
def handle_calculator(expression):
    """
    Evaluate a mathematical expression and return the result.
    ...
    """
    ...

@mcp.tool()
def handle_file_read(path):
    """
    Read the contents of a file at the given path.
    ...
    """
    ...

@mcp.tool()
def handle_file_write(path: str, content: str):
    """
    Write content to a file at the given path.
    ...
    """
    ...
```

### Run MCP server

```python
# filepath: f:\Workspace\AI Training\Gemini CLI\src\server.py
if __name__ == "__main__":
    mcp.run()
```

By default, the server listens on STDIO, ready to process incoming tool calls from the Gemini CLI. The `transport` parameter of `mcp.run()` can adjust this behavior.

## Setup

1. Install Python 3.6+ and Poetry.
2. In project folder run:
   ```powershell
   poetry install
   ```
   (No external dependencies required)

## Running MCP Server

Start the MCP server (STDIO transport):

```powershell
poetry run python src/server.py
```

The process stays attached to STDIO (no TCP port).

## Gemini CLI Integration

The Gemini CLI is configured to connect to this MCP server via `.gemini/settings.json` (command points to `python src/server.py`).

Launch Gemini CLI:

```powershell
gemini
```

Use `/mcp` inside the CLI to list connected MCP servers and tools.

![MCP Server Tools](assets/mcp_tools_list_in_gemini_cli.png)

The Gemini agent can invoke these tools in based on the need.

You may ask naturally (e.g. “Compute 2 + 2 \* 3” or “Read ./notes.txt”) and the agent will call the appropriate tool.

## Usage Examples

**User:** "Hey, what's 15% tip on a $47.50 bill?"

**Agent:** _[Proposes to use calculator tool: 47.50 _ 0.15]\_
![gemini_asking_for_permission_to_run_mcp_tool.png](assets/gemini_asking_for_permission_to_run_mcp_tool.png)

**Tool Call and Response: (Upon Approval from the User)**
✓ handle_calculator (pythonTools MCP Server) {"expression":"47.50 \* 0.15"}

![gemini_tool_executed_successfully.png](assets/tool_response.png)

---