Kite MCP Server

To run the server locally with your own Kite Connect API credentials, follow these steps:

1. Prerequisites: Ensure you have Go 1.21 or later installed.
2. Clone the repository:

   git clone https://github.com/zerodha/kite-mcp-server
   cd kite-mcp-server

3. Configure environment variables: Create a .env file in the root directory with your credentials:

   KITE_API_KEY=your_api_key
   KITE_API_SECRET=your_api_secret
   APP_MODE=http
   APP_PORT=8080
   APP_HOST=localhost
   PUBLIC_BASE_URL=http://localhost:8080

   Alternatively, use just init-env to initialize the config.
4. Run the server:

   # Build and run
   go build -o kite-mcp-server
   ./kite-mcp-server
   
   # Or run directly
   go run main.go

To use the hosted Kite MCP server with Claude Desktop, add the following configuration to your claude_desktop_config.json file. This uses mcp-remote to bridge the connection.

{
  "mcpServers": {
    "kite": {
      "command": "npx",
      "args": ["mcp-remote", "https://mcp.kite.trade/mcp"]
    }
  }
}

The easiest way to use Kite MCP is via the hosted version at mcp.kite.trade. This requires no installation or local API keys. You can connect your AI client directly to the hosted endpoints.

Quick Setup: Add https://mcp.kite.trade/mcp to your MCP client configuration.

The server's behavior is determined by the APP_MODE environment variable. The available modes are:

• sse: Server-Sent Events mode. Provides endpoints for SSE-based MCP communication.
• stdio: Standard IO mode. Typically used for local CLI-based MCP integrations.
• http: Streamable HTTP mode. Provides a single /mcp endpoint for streamable HTTP MCP communication.
• hybrid: Combined mode. Enables both SSE and MCP endpoints on the same server.

Defaults:

• APP_MODE: http (via DefaultAppMode)
• APP_PORT: 8080 (via DefaultPort)
• APP_HOST: localhost (via DefaultHost)

To use the Kite MCP Server in a Go application, use the app package to create a new application instance, load its configuration, and start the server. The server can run in several modes depending on your integration needs (SSE, StdIO, HTTP, or Hybrid).

1. Call NewApp(logger) with a *slog.Logger to initialize the application.
2. Call LoadConfig() to validate environment variables.
3. Call RunServer() to start the lifecycle management and the chosen server mode.

package main

import (
	"log/slog"
	"github.com/zerodha/kite-mcp-server/app"
)

func main() {
	logger := slog.Default()
	appInstance := app.NewApp(logger)

	if err := appInstance.LoadConfig(); err != nil {
		panic(err)
	}

	if err := appInstance.RunServer(); err != nil {
		panic(err)
	}
}

To prevent an AI agent from performing destructive actions (like placing or canceling orders), you can exclude specific tools by setting the EXCLUDED_TOOLS environment variable with a comma-separated list of tool names.

Example for a read-only setup:

EXCLUDED_TOOLS=place_order,modify_order,cancel_order

The Kite MCP Server uses structured logging via slog. You can control the verbosity of the logs by setting the LOG_LEVEL environment variable. The server logs to os.Stderr.

# Example: Set log level to debug
export LOG_LEVEL=debug

The app.Config struct is populated from the following environment variables:

Use these environment variables to configure the self-hosted server behavior.

| Environment Variable | Default | Description |
| -------------------- | ------- | ----------- |
| `KITE_API_KEY` | Required | Your Kite Connect API key |
| `KITE_API_SECRET` | Required | Your Kite Connect API secret |
| `APP_MODE` | `http` | Server mode: `stdio`, `http`, `sse`, or `hybrid` |
| `APP_PORT` | `8080` | Server port (HTTP/SSE/hybrid modes) |
| `APP_HOST` | `localhost` | Server host / bind address (HTTP/SSE/hybrid modes) |
| `PUBLIC_BASE_URL` | derived | Public base URL used for browser-facing auth links |
| `EXCLUDED_TOOLS` | _(empty)_ | Comma-separated list of tools to exclude from registration |

The following values are accepted for the LOG_LEVEL environment variable:

• debug
• info (default)
• warn
• error