MCP Agent Tracker

A Model Context Protocol (MCP) server that automatically tracks client-agent conversations without requiring any user interaction.

Features

🗣️ Automatic Conversation Tracking

• Zero User Interaction Required: All conversations are tracked automatically

• Client Request Logging: Every client prompt/request is logged

• Agent Response Logging: Every agent response is captured

• Complete Conversation Turns: Full request-response pairs are recorded

• Session Management: Automatic session creation and tracking

🔧 MCP Tools Available

• get_current_weather(city): Get weather information for a city

• agent_interaction(prompt): Interact with the agent

• get_interaction_history(limit, session_id): Retrieve conversation history

• get_conversation_summary(session_id): Get conversation statistics and patterns

📊 Automatic Monitoring

• Background Health Checks: Continuous system monitoring every 5 minutes

• Automatic Metadata Collection: System info, process details, uptime

• Error Tracking: Comprehensive error logging and recovery

• Performance Metrics: Execution times and system health

Related MCP server: MCP Work History Server

How It Works

1. Automatic Session Creation

# Sessions are created automatically when the server starts
# No user input required
logger.get_or_create_session()

2. Client Request Tracking

# Every client request is automatically logged
logger.log_client_request(f"Get weather for {city}")

3. Agent Response Tracking

# Every agent response is automatically captured
logger.log_agent_response(response)

4. Complete Conversation Logging

# Full conversation turns are recorded
logger.log_conversation_turn(
    client_request=f"Get weather for {city}",
    agent_response=response
)

5. Background Monitoring

# System health is monitored continuously
# No user interaction needed
def background_monitoring():
    while True:
        logger.log_interaction(interaction_type='health_check', ...)
        time.sleep(Config.MONITORING_INTERVAL_SECONDS)

Configuration

Environment Variables

# Enable/disable features
ENABLE_BACKGROUND_MONITORING=true
MONITORING_INTERVAL_SECONDS=300
ENABLE_AUTOMATIC_METADATA=true

# Database and logging
DATABASE_URL=
DB_PATH=./data/agent_tracker.db
LOG_LEVEL=INFO

Configuration Options

• ENABLE_BACKGROUND_MONITORING: Enable continuous system monitoring

• MONITORING_INTERVAL_SECONDS: How often to run health checks (default: 300s)

• ENABLE_AUTOMATIC_METADATA: Collect system info automatically

Database Schema

AgentInteraction Table

CREATE TABLE agent_interactions (
    id INTEGER PRIMARY KEY,
    timestamp TIMESTAMP,
    session_id VARCHAR(255),
    user_id VARCHAR(255),
    interaction_type VARCHAR(100),  -- 'client_request', 'agent_response', 'conversation_turn'
    prompt TEXT,                    -- Client request
    response TEXT,                  -- Agent response
    status VARCHAR(50),
    error_message TEXT,
    meta_data JSON                  -- Automatic system metadata
);

Session Table

CREATE TABLE sessions (
    id VARCHAR(255) PRIMARY KEY,
    user_id VARCHAR(255),
    started_at TIMESTAMP,
    last_activity TIMESTAMP,
    total_interactions INTEGER,
    meta_data JSON
);

Usage Examples

Basic Conversation Tracking

@mcp.tool()
def my_tool(prompt: str) -> str:
    # Client request is automatically logged
    logger.log_client_request(prompt)

    # Process the request
    response = process_request(prompt)

    # Agent response is automatically logged
    logger.log_agent_response(response)

    # Complete conversation turn is recorded
    logger.log_conversation_turn(prompt, response)

    return response

Getting Conversation History

# Get recent conversations
history = get_interaction_history(limit=10)

# Get conversation summary
summary = get_conversation_summary()

Security Features

• Environment Variables: All configuration via environment variables

• No Hardcoded Secrets: Secure credential management

• Isolated Database Schema: Separate schema for tracking data

• Error Isolation: Logging failures don't break main functionality

Getting Started

1. Copy environment file:

   cp env.example .env

2. Configure your environment:

   # Edit .env with your settings
   ENABLE_BACKGROUND_MONITORING=true
   MONITORING_INTERVAL_SECONDS=300

3. Run the server:

   python main.py

4. Monitor conversations:

   # Use the MCP tools to interact and track conversations

🚀 Using in Cursor

Prerequisites

• Cursor IDE installed on your system

• Python 3.8+ with pip/uv package management

• Git for cloning the repository

Step 1: Setup MCP Server

1. Clone and navigate to your project:

   cd /path/to/your/mcp/project

2. Install dependencies:

   # Using pip
   pip install -r requirements.txt
   
   # Or using uv (recommended)
   uv sync

3. Configure environment:

   cp env.example .env
   # Edit .env with your preferred settings

Step 2: Configure Cursor for MCP

1. Open Cursor Settings:

   • Press Cmd+, (Mac) or Ctrl+, (Windows/Linux)

   • Or go to Cursor → Preferences → Settings

2. Add MCP Configuration:

   {
     "mcpServers": {
       "mcp-project": {
         "command": "python",
         "args": ["/absolute/path/to/your/project/main.py"],
         "env": {
           "PYTHONPATH": "/absolute/path/to/your/project"
         }
       }
     }
   }

3. Alternative: Use relative paths (if Cursor is opened in project directory):

   {
     "mcpServers": {
       "mcp-project": {
         "command": "python",
         "args": ["./main.py"]
       }
     }
   }

Step 3: Test MCP Integration

1. Restart Cursor after adding MCP configuration

2. Open Command Palette (Cmd+Shift+P or Ctrl+Shift+P)

3. Type "MCP" to see available MCP commands

4. Test a tool:

   • Use get_current_weather("New York") to test weather functionality

   • Use agent_interaction("Hello, how are you?") to test conversation tracking

   • Use get_system_status() to check system health

Step 4: Use MCP Tools in Cursor

Available Tools

• get_current_weather(city): Get weather for any city

• agent_interaction(prompt): Interact with the agent and track conversations

• get_interaction_history(limit, session_id): View conversation history

• get_conversation_summary(session_id): Get conversation analytics

• get_system_status(): Check system health and configuration

• test_conversation_tracking(message): Test the tracking system

Example Usage in Cursor

1. Open Command Palette (Cmd+Shift+P)

2. Type MCP command:

   MCP: mcp-project: get_current_weather

3. Enter parameters when prompted:

   city: San Francisco

4. View results in the output panel

Step 5: Monitor and Debug

View Conversation History

# In Cursor terminal or via MCP tools
python -c "
from main import get_interaction_history
print(get_interaction_history(limit=5))
"

Check System Status

# Via MCP tools in Cursor
get_system_status()

Test Conversation Tracking

# Via MCP tools in Cursor
test_conversation_tracking("Test message from Cursor")

Troubleshooting

Common Issues

1. "MCP server not found":

   • Check the absolute path in your Cursor settings

   • Ensure the Python path is correct

   • Verify the server is running

2. "Import errors":

   • Check PYTHONPATH in MCP configuration

   • Ensure all dependencies are installed

   • Verify you're in the correct directory

3. "Permission denied":

   • Make sure main.py is executable

   • Check file permissions

   • Try running with python3 instead of python

Debug Commands

# Test MCP server directly
python main.py

# Check dependencies
pip list | grep mcp

# Verify configuration
python -c "from config import Config; print(Config.ENVIRONMENT)"

Advanced Configuration

Custom MCP Server Names

{
  "mcpServers": {
    "my-custom-mcp": {
      "command": "python",
      "args": ["./main.py"],
      "env": {
        "ENVIRONMENT": "development",
        "LOG_LEVEL": "DEBUG"
      }
    }
  }
}

Multiple MCP Servers

{
  "mcpServers": {
    "mcp-project": { "command": "python", "args": ["./main.py"] },
    "another-mcp": { "command": "python", "args": ["./other_mcp.py"] }
  }
}

Benefits in Cursor

✅ Seamless Integration: Use MCP tools directly in your IDE
✅ Real-time Monitoring: Track conversations as you work
✅ Debugging Tools: Built-in testing and monitoring functions
✅ Performance Insights: Monitor system health and usage
✅ Conversation Analytics: Analyze interaction patterns
✅ Zero Configuration: Automatic setup and tracking

Your MCP server will now be fully integrated with Cursor, providing powerful conversation tracking and monitoring capabilities right in your development environment!

What Gets Tracked Automatically

✅ Client Requests: Every prompt, question, or request
✅ Agent Responses: Every response, answer, or action
✅ Conversation Flow: Complete request-response pairs
✅ System Health: Background monitoring and metrics
✅ Error Handling: All errors and exceptions
✅ Session Data: User sessions and activity
✅ Metadata: System info, timestamps, environment

❌ Tool Usage: Internal MCP tool executions are not tracked
❌ User Input: No manual logging required
❌ Configuration: Automatic setup and management

The system is designed to be completely hands-off - once started, it will track all client-agent conversations automatically without any intervention needed.