MCP Server (Multi-Context Protocol Server)

The MCP Server is an AI-powered integration system that automatically manages project items across multiple platforms (GitHub, Jira, Linear) by listening to terminal coding tools and conversations.

Overview

The MCP Server bridges the gap between your development workflow and project management systems. It listens to coding activities, analyzes them using AI, and automatically creates or updates corresponding issues/tickets in your project management tools.

Architecture

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   GitHub        │    │   JIRA          │    │   Linear        │
│   Issues/PRs    │    │   Tickets       │    │   Issues        │
└─────────┬───────┘    └─────────┬───────┘    └─────────┬───────┘
          │                      │                      │
          └──────────────────────┼──────────────────────┘
                                 │
                    ┌─────────────────────────────┐
                    │       MCP Server          │
                    │     (Integration Hub)     │
                    │                           │
                    │ ┌─────────────────────────┐ │
                    │ │   AI Context Engine     │ │
                    │ │  (LLM Analysis & NLP)   │ │
                    │ └─────────────────────────┘ │
                    │ ┌─────────────────────────┐ │
                    │ │   Data Ingestion Layer  │ │
                    │ │ (Multiple formats &     │ │
                    │ │  sources)               │ │
                    │ └─────────────────────────┘ │
                    │ ┌─────────────────────────┐ │
                    │ │   Conversation Manager  │ │
                    │ │ (Terminal, Files, etc)  │ │
                    │ └─────────────────────────┘ │
                    │ ┌─────────────────────────┐ │
                    │ │   Monitoring & Observ.  │ │
                    │ │    (Langfuse/LiteLLM)   │ │
                    │ └─────────────────────────┘ │
                    └─────────────┬───────────────┘
                                  │
              ┌───────────────────┼───────────────────┐
              │                   │                   │
    ┌─────────▼────────┐  ┌───────▼───────┐  ┌───────▼────────┐
    │ Terminal Tools   │  │ Data Sources  │  │ AI/LLM Models  │
    │ (Cursor, VSCode, │  │ (JSON, MD,    │  │ (Context       │
    │ Vim, etc)        │  │ CSV, XML, etc)│  │ Processing)    │
    └──────────────────┘  └───────────────┘  └────────────────┘

Features

Multi-Platform Support

• Linear: Issues, Projects, Cycles, Pulses, Reviews, Views, Initiatives, Customers, Teams
• GitHub: Issues, Pull Requests, Projects
• Jira: Issues, Projects, Epics, Stories

AI Provider Support

• OpenAI: GPT-4, GPT-3.5-turbo and other models
• Anthropic: Claude 3 models
• OpenRouter: Access to multiple models through one API
• Ollama: Local models for privacy-conscious users

Data Ingestion

• Multiple format support: JSON, YAML, Markdown, CSV, XML, TXT, SQL
• File-based ingestion from terminal tools
• Stream-based ingestion for real-time processing
• Multi-source consolidation

Monitoring & Observability

• Langfuse Integration: Full observability for AI calls and operations
• Performance tracking: Latency, token usage, success rates
• Error tracking and analysis
• Conversation analysis metrics

Installation

1. Clone the repository:

   git clone https://github.com/yourusername/mcp-server-project.git
   cd mcp-server-project

2. Install dependencies:

   pip install -r requirements.txt
   # For extended features including monitoring:
   pip install -r requirements_extended.txt

3. Set up environment variables:

   cp .env.example .env
   # Edit .env with your API keys and configuration

Configuration

Environment Variables

The server requires several environment variables to function:

• OPENAI_API_KEY: For OpenAI integration
• ANTHROPIC_API_KEY: For Anthropic integration
• LINEAR_API_KEY: For Linear integration
• LANGFUSE_PUBLIC_KEY & LANGFUSE_SECRET_KEY: For monitoring (optional)

Main Configuration

Configuration is managed through config/config.py which provides:

• Server settings (host, port, etc.)
• AI provider configuration
• Integration settings
• Data source settings
• Monitoring configuration
• Feature flags

Usage

Starting the Server

cd mcp_server
python server_ai_enabled.py

API Endpoints

• POST /event: Process events from terminal tools
• POST /ingest: Ingest data from various sources
• POST /analyze: Analyze data using AI
• POST /monitor_directory: Monitor directories for conversation files
• GET /health: Check server health
• GET /configured_platforms: List configured platforms
• GET /available_ai_providers: List available AI providers

Terminal Tool Integration

The server can monitor your terminal coding environment for:

• File changes that might indicate bugs to fix
• Git operations that correspond to issues
• Conversation logs from AI coding assistants
• Commit messages that close issues

Monitoring & Observability

Langfuse Integration

The server includes comprehensive monitoring via Langfuse:

1. AI Call Tracking: Every AI API call is tracked with:

   • Input prompts and output responses
   • Latency measurements
   • Token usage
   • Success/failure status

2. Conversation Analysis Tracking:

   • What conversations were analyzed
   • What actions were suggested
   • Which provider was used

3. Linear Operations Tracking:

   • Issues created/updated/closed
   • Projects created
   • Success metrics

To enable Langfuse:

1. Sign up at https://langfuse.com
2. Get your public and secret keys
3. Set LANGFUSE_PUBLIC_KEY and LANGFUSE_SECRET_KEY environment variables
4. Set MCP_MONITORING_ENABLED=true and MCP_MONITORING_PROVIDER=langfuse

The monitoring dashboard will show you:

• AI usage patterns
• Performance metrics
• Error rates
• Token consumption
• Conversation analysis effectiveness

LiteLLM Proxy (Alternative)

Alternatively, you can use LiteLLM proxy for monitoring:

1. Set MCP_MONITORING_PROVIDER=litellm
2. Configure LITELLM_PROXY_HOST and LITELLM_API_KEY

Security

• API keys are stored securely and never logged
• All communication is encrypted
• Rate limiting prevents abuse
• Input sanitization prevents injection attacks

Extending

The server is designed to be extensible:

1. New AI Providers: Implement the AIProvider interface
2. New Integrations: Add new platform managers following the Linear manager pattern
3. New Data Sources: Extend the DataIngestor class
4. New Monitoring Providers: Add new monitoring integrations

Environment Configuration

The server supports multiple environments:

• Development: ENVIRONMENT=development
• Staging: ENVIRONMENT=staging
• Production: ENVIRONMENT=production

Troubleshooting

1. API Key Issues: Verify your environment variables are set correctly
2. Monitoring Not Working: Check Langfuse API keys and network connectivity
3. AI Provider Issues: Verify the provider is enabled in config and has valid credentials
4. Terminal Monitoring Not Working: Check file paths and permissions

API Schema Documentation

Linear API Schema

Mutation: issueCreate
  - title: String!
  - description: String
  - projectId: String
  - teamId: String!
  - priority: Int
  - labels: [String!]

Mutation: projectCreate
  - name: String!
  - description: String
  - teamId: String
  - startDate: Date
  - targetDate: Date

Query: issues
  - filter parameters for existing issues
  - status tracking
  - relationship mapping

Contributing

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Make your changes
4. Add tests if applicable
5. Run tests (pytest)
6. Commit your changes (git commit -m 'Add some amazing feature')
7. Push to the branch (git push origin feature/amazing-feature)
8. Open a Pull Request

License

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