A comprehensive Model Context Protocol (MCP) server that provides intelligent orchestration, queuing, and advanced features for LM Studio integration.

• Intelligent Model Selection: Automatically selects the best model based on task complexity, requirements, and performance metrics
• Task Queuing & Orchestration: Asynchronous task processing with priority queues and intelligent scheduling
• RAG Integration: Retrieval-Augmented Generation with vector stores and similarity search
• LangChain Integration: Advanced text processing, chunking, and embeddings
• Agentic Flows: Support for autonomous tool-calling workflows
• Conversation Context Management: Persistent conversation contexts with automatic cleanup
• Performance Monitoring: Real-time model performance tracking and optimization

• Multi-Model Support: Seamless switching between LLM and embedding models
• Streaming Responses: Real-time streaming for chat completions
• Vision Model Support: Integration with vision-language models
• Tool Integration: Custom tool definitions for agentic workflows
• Vector Stores: Create and manage multiple vector stores for RAG
• Similarity Search: Advanced semantic search capabilities
• Configuration Management: Flexible configuration with environment variables and files

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   MCP Client    │◄──►│  MCP Server     │◄──►│   LM Studio     │
│                 │    │                 │    │                 │
└─────────────────┘    └─────────────────┘    └─────────────────┘
                              │
                              ▼
                    ┌─────────────────┐
                    │  Orchestrator   │
                    │                 │
                    └─────┬───────────┘
                          │
            ┌─────────────┼─────────────┐
            ▼             ▼             ▼
    ┌──────────────┐ ┌──────────────┐ ┌──────────────┐
    │ Task Queue   │ │ RAG Service  │ │ LangChain    │
    │              │ │              │ │              │
    └──────────────┘ └──────────────┘ └──────────────┘
            │             │             │
            ▼             ▼             ▼
    ┌──────────────┐ ┌──────────────┐ ┌──────────────┐
    │ Redis Queue  │ │ Vector Store │ │ Text Splitter│
    │              │ │              │ │              │
    └──────────────┘ └──────────────┘ └──────────────┘

• Node.js 18+
• LM Studio running with API enabled
• Redis server (for queuing)
• TypeScript

1. Clone and install dependencies:

cd servers/lmstudio-server
npm install

2. Configure environment:

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

3. Build the server:

npm run build

4. Start LM Studio:

   • Launch LM Studio
   • Load your preferred models
   • Enable the API server (typically on port 1234)

5. Start Redis (required for queuing):

# On Windows with Redis installed
redis-server

# On macOS with Homebrew
brew services start redis

# On Ubuntu/Debian
sudo systemctl start redis-server

6. Run the server:

npm start

See .env.example for all available configuration options:

• LM Studio: Connection settings, timeouts, retry logic
• Database: SQLite, PostgreSQL, or MongoDB for persistence
• Queue: Redis configuration and concurrency settings
• RAG: Vector store settings, chunk sizes, similarity thresholds
• Model Selection: Strategy and auto-loading preferences
• Monitoring: Logging levels and metrics collection

Alternatively, create a config.json file:

{
  "lmstudio": {
    "baseUrl": "http://localhost:1234",
    "timeout": 60000
  },
  "langchain": {
    "enableRAG": true,
    "embeddingModel": "nomic-embed-text-v1.5",
    "chunkSize": 1000
  },
  "modelSelection": {
    "strategy": "performance",
    "autoLoad": true
  }
}

• chat_completion: Intelligent chat with context management
• text_completion: Text completion with model selection
• rag_query: RAG-powered question answering

• load_model: Load models with intelligent selection
• unload_model: Unload specific models
• list_models: List available and loaded models
• get_model_info: Get detailed model information
• get_model_performance: Performance metrics for all models

• create_vector_store: Create new vector stores
• add_documents_to_vector_store: Add documents from text or files
• search_vector_store: Semantic similarity search
• list_vector_stores: List all vector stores
• delete_vector_store: Remove vector stores

• start_agentic_flow: Begin autonomous tool-calling workflows
• get_task_status: Monitor task progress
• cancel_task: Cancel running tasks

• create_embeddings: Generate embeddings
• similarity_search: Calculate semantic similarity
• count_tokens: Token counting for any text
• get_system_status: Comprehensive system status
• get_queue_stats: Queue statistics and health

{
  "tool": "chat_completion",
  "arguments": {
    "messages": "Explain quantum computing in simple terms",
    "temperature": 0.7,
    "maxTokens": 500,
    "modelHints": {
      "complexity": "medium"
    }
  }
}

{
  "tool": "rag_query",
  "arguments": {
    "query": "What are the benefits of renewable energy?",
    "vectorStoreId": "environmental_docs",
    "maxTokens": 800,
    "retrievalConfig": {
      "maxRelevantChunks": 5,
      "similarityThreshold": 0.8
    }
  }
}

{
  "tool": "create_vector_store",
  "arguments": {
    "id": "company_docs",
    "name": "Company Documentation",
    "filePaths": [
      "./docs/handbook.txt",
      "./docs/policies.md",
      "./docs/procedures.pdf"
    ]
  }
}

{
  "tool": "start_agentic_flow",
  "arguments": {
    "name": "Data Analysis Flow",
    "description": "Analyze data and create visualizations",
    "initialPrompt": "Analyze the sales data and create a summary report",
    "tools": [
      {
        "name": "read_file",
        "description": "Read data from a file",
        "parameters": { "path": "string" },
        "implementation": "return fs.readFileSync(args.path, 'utf-8');"
      },
      {
        "name": "calculate_stats",
        "description": "Calculate basic statistics",
        "parameters": { "data": "array" },
        "implementation": "return { mean: args.data.reduce((a,b) => a+b)/args.data.length };"
      }
    ],
    "maxRounds": 10
  }
}

{
  "tool": "load_model",
  "arguments": {
    "taskType": "code_generation",
    "complexity": "high",
    "requiresToolUse": true,
    "config": {
      "contextLength": 16384,
      "gpu": { "ratio": 0.8 }
    }
  }
}

The server automatically selects the best model for each task based on:

• Task complexity (auto-detected from input)
• Required capabilities (vision, tool use, etc.)
• Model performance metrics
• Resource availability
• User preferences

• Priority Queues: HIGH, MEDIUM, LOW priority levels
• Concurrent Processing: Configurable concurrency per queue type
• Retry Logic: Exponential backoff for failed tasks
• Progress Tracking: Real-time task status monitoring

• Persistent Contexts: Maintain conversation state across requests
• Automatic Cleanup: Remove old contexts to manage memory
• Token Tracking: Monitor context length to prevent overflow

Get comprehensive system information:

{
  "tool": "get_system_status",
  "arguments": {}
}

Returns:

• Queue statistics
• Loaded models
• Performance metrics
• RAG statistics
• Active conversations
• Memory usage

{
  "tool": "get_model_performance",
  "arguments": {}
}

Tracks:

• Average latency per model
• Tokens per second
• Success rates
• Memory usage
• Usage patterns

Configurable log levels:

• debug: Detailed execution information
• info: General operational info
• warn: Warnings and degraded performance
• error: Errors and failures

Logs are written to:

• Console (with colors)
• ./logs/combined.log (all logs)
• ./logs/error.log (errors only)

1. Performance: Select based on speed and accuracy metrics
2. Availability: Use currently loaded models when possible
3. Cost: Optimize for computational efficiency

• Chunk Sizes: Adjust for your document types
• Overlap: Balance context preservation vs. performance
• Similarity Thresholds: Fine-tune relevance filtering
• Reranking: Enable for improved result quality

• Concurrency: Balance throughput vs. resource usage
• TTL: Automatic model unloading after idle time
• Cleanup: Regular maintenance of completed tasks

1. Connection Refused: Ensure LM Studio API is running on the correct port
2. Redis Connection: Verify Redis server is running and accessible
3. Model Loading: Check available models in LM Studio
4. Memory Issues: Adjust concurrency and model limits
5. Performance: Monitor queue stats and adjust priorities

LOG_LEVEL=debug npm start

{
  "tool": "get_system_status",
  "arguments": {}
}

1. Fork the repository
2. Create your feature branch (git checkout -b feature/AmazingFeature)
3. Commit your changes (git commit -m 'Add some AmazingFeature')
4. Push to the branch (git push origin feature/AmazingFeature)
5. Open a Pull Request

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

For issues and questions:

• Check the troubleshooting section
• Review logs for error details
• Open an issue with reproduction steps
• Include system status output when reporting bugs