MCP
OpenAlgo - Model Context Protocol
OpenAlgo MCP - AI Trading Assistant
An AI-powered trading assistant platform for OpenAlgo, leveraging Model Context Protocol (MCP) and Large Language Models to provide intelligent trading capabilities.
Overview
OpenAlgo MCP integrates the powerful OpenAlgo trading platform with advanced AI capabilities through:
An MCP server that exposes OpenAlgo API functions as tools for AI interaction
An intelligent client application providing a conversational interface for trading
This bridge between OpenAlgo's trading capabilities and AI allows for a natural language interface to complex trading operations, making algorithmic trading more accessible to users of all technical backgrounds.

Key Features
Comprehensive Trading Capabilities
Order Management: Place, modify, and cancel orders with support for various order types (market, limit, stop-loss)
Advanced Order Types: Basket orders, split orders, and smart orders with position sizing
Market Data Access: Real-time quotes, market depth, and historical data
Portfolio Management: Track holdings, positions, order books, and trade history
Account Information: Monitor funds, margins, and trading limits
Intelligent Symbol Format Handling
Smart parsing and formatting of instrument symbols across exchanges
Support for equity, futures, and options symbology
Built-in knowledge of common indices and exchange-specific formats
AI-Powered Trading Assistant
Natural language interface for all trading operations
Contextual understanding of trading terminology and concepts
Guided assistance for complex trading operations
Real-time data presentation in human-readable formats
Project Structure
openalgo-mcp/
├── .env # Common environment configuration
├── .env.example # Example configuration template
├── requirements.txt # Common dependencies for both client and server
├── LICENSE # MIT License
├── server/ # MCP Server implementation
│ ├── server.py # OpenAlgo MCP server code
└── client/ # Client implementation
├── trading_agent.py # AI assistant client code
Installation Guide
Prerequisites
Python 3.9+ installed
OpenAlgo platform installed and configured
OpenAI API key (for the client component)
Step 1: Clone the Repository
git clone https://github.com/marketcalls/openalgo-mcp.git
cd openalgo-mcp/mcpserver
Step 2: Set Up Environment
# Create and activate virtual environment
python -m venv venv
source venv/bin/activate # On Windows: venv\Scripts\activate
# Install dependencies
pip install -r requirements.txt
Step 3: Configure Environment Variables
# Copy example environment file
cp .env.example .env
# Edit the .env file with your API keys and settings
# vim .env or use any text editor
Usage
Starting the MCP Server
cd server
python server.py
The server supports the following options:
--api-key
: OpenAlgo API key (alternative to setting in .env)--host
: OpenAlgo API host URL (default: http://127.0.0.1:5000)--port
: Server port (default: 8001)--mode
: Server transport mode - 'stdio' or 'sse' (default: sse)
Starting the Trading Assistant Client
cd client
python trading_agent.py
The client supports these options:
--host
: MCP server host (default: from .env)--port
: MCP server port (default: from .env)--model
: OpenAI model to use (default: from .env)
Configuration
The project uses a unified configuration approach with environment variables:
Common configuration is stored in the root
.env
fileComponent-specific configuration can be set in
server/.env
orclient/.env
Common settings will be loaded first, then possibly overridden by component-specific settings
Required API Keys
OpenAlgo API Key - Set in
.env
asOPENALGO_API_KEY
Required for accessing the OpenAlgo trading platform
Obtain from your OpenAlgo account dashboard
OpenAI API Key - Set in
.env
asOPENAI_API_KEY
(for the client only)Required for the AI assistant capabilities
Obtain from OpenAI Platform
Technical Capabilities
The OpenAlgo MCP implementation provides comprehensive API coverage including:
Order Management:
place_order
: Standard order placementmodify_order
: Order modification with parameter validationcancel_order
: Order cancellation by ID
Advanced Order Types:
place_basket_order
: Place multiple orders simultaneouslyplace_split_order
: Split large orders into smaller chunksplace_smart_order
: Position-aware order placement
Market Data:
get_quote
: Latest market quotesget_depth
: Order book depth dataget_history
: Historical price data with various timeframes
Account Information:
get_funds
: Available funds and marginget_holdings
: Portfolio holdingsget_position_book
,get_order_book
,get_trade_book
: Trading records
Symbol Information:
get_symbol_metadata
: Detailed symbol informationget_all_tickers
: Available trading symbolsget_intervals
: Supported timeframes for historical data
The implementation uses FastMCP with SSE (Server-Sent Events) transport for real-time communication and includes proper error handling, logging, and parameter validation.
Server Implementation Details
The OpenAlgo MCP Server is built using the FastMCP library and exposes OpenAlgo trading functionality through a comprehensive set of tools. It uses Server-Sent Events (SSE) as the primary transport mechanism for real-time communication.
Server Architecture
Framework: Uses FastMCP with Starlette for the web server
Transport: Server-Sent Events (SSE) for real-time bidirectional communication
API Client: Wraps the OpenAlgo API with appropriate error handling and logging
Configuration: Uses environment variables with command-line override capabilities
Available API Tools
The server exposes over 15 trading-related tools, including:
Order Management: place_order, modify_order, cancel_order, get_order_status
Advanced Orders: place_basket_order, place_split_order, place_smart_order
Market Data: get_quote, get_depth, get_history, get_intervals
Account Information: get_funds, get_holdings, get_position_book, get_order_book, get_trade_book
Symbol Information: get_symbol_metadata, get_all_tickers
Client Implementation Details
The Trading Assistant client provides a user-friendly interface to interact with the OpenAlgo platform through natural language. It uses OpenAI's language models to interpret user commands and invoke the appropriate trading functions.
Client Architecture
Framework: Uses Agno agent framework with OpenAI Chat models
UI: Rich console interface with custom styling for an enhanced terminal experience
Symbol Helper: Built-in utilities for correct symbol formatting across exchanges
Error Handling: Comprehensive exception handling with user-friendly feedback
Trading Assistant Capabilities
Natural Language Interface: Understands trading terminology and concepts
Symbol Format Assistance: Helps construct proper symbol formats for equities, futures, and options
Data Presentation: Formats market data in clean, readable formats
Contextual Awareness: Maintains conversation history to provide contextual responses
Troubleshooting Guide
Common Issues
Connection Issues
If you're having trouble connecting to the MCP server:
Verify the server is running:
cd server python server.py
You should see output indicating the server is running on the configured port.
Check environment variables:
Ensure
MCP_HOST
andMCP_PORT
in.env
match the server's configurationVerify that
SERVER_PORT
is the same asMCP_PORT
Test local connectivity:
Try accessing
http://localhost:8001/sse
in your browser (replace 8001 with your configured port)You should see a message indicating the endpoint is for SSE connections
API Authentication Issues
If you see 403 Forbidden or authentication errors:
Check your API key:
Verify your OpenAlgo API key in the
.env
file is correct and activeEnsure the API key has the necessary permissions for the operations you're trying to perform
Verify API host:
Make sure
OPENALGO_API_HOST
points to the correct endpointFor testing, the default value
http://127.0.0.1:5000
should work if you're running OpenAlgo locally
Client Issues
Silent failures in the client:
The client uses a SilentFilter for logging to provide a clean interface
If you suspect issues, temporarily modify the logging configuration in
trading_agent.py
Check that the OpenAI API key is valid if you experience model generation failures
Acknowledgements and Credits
This project is made possible by the following open-source projects and tools:
Core Technologies
OpenAlgo: The powerful trading platform that powers all trading operations in this project
Model Context Protocol (MCP): The communication protocol that enables AI agents to use tools and APIs
Agno: The agent framework used for building the trading assistant client
Inspiration
This project was inspired by Zerodha MCP, which pioneered the use of Model Context Protocol for trading applications. The OpenAlgo MCP project adapts and extends this concept for the OpenAlgo trading platform, with a focus on enhanced symbol handling, comprehensive trading operations, and a more user-friendly interface.
Symbol Formatting Issues
If your symbol-related requests are failing:
Follow format guidelines:
Equity symbols: Simple uppercase symbol (e.g.,
INFY
,SBIN
)Futures:
[BaseSymbol][Year][Month][Date]FUT
(e.g.,BANKNIFTY24APR24FUT
)Options:
[BaseSymbol][Date][Month][Year][Strike][OptionType]
(e.g.,NIFTY28MAR2420800CE
)
Use the SymbolHelper class:
The client includes formatting assistance methods that can help construct proper symbols
Debugging Mode
For more detailed logging, enable debugging in the .env
file:
SERVER_DEBUG=true
This will output additional information to help diagnose connection and API issues.
License
This project is licensed under the Apache-2.0 license - see the LICENSE file for details.
Last updated