angel-one-mcp 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mohamed Ameer Noufil N (https://ameernoufil.in)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,120 @@
+# Angel One MCP Server
+
+A [Model Context Protocol](https://modelcontextprotocol.io) server that exposes [Angel One SmartAPI](https://smartapi.angelone.in/) as tools for LLM clients like Claude Desktop, Claude Code, and other MCP-compatible apps.
+
+Trade stocks, track portfolios, analyze markets, and manage orders — all through natural language.
+
+## Features
+
+- **30+ tools** covering orders, portfolio, market data, GTT rules, and more
+- **Auto TOTP** — generates login codes automatically, no manual entry
+- **Lazy authentication** — logs in on first API call, refreshes tokens proactively
+- **Safety guards** — two-tier soft/hard limits on order quantity and value to prevent fat-finger trades
+- **Zero SDK dependency** — direct `fetch()` calls to Angel One REST API
+
+---
+
+## Quick Start
+
+> Copy the prompt below and paste it into your AI agent. It will handle the rest.
+
+```
+Install and configure the Angel One MCP server by following the instructions here:
+https://raw.githubusercontent.com/ameernoufil/angel-one-mcp/main/docs/llm-setup.md
+```
+
+---
+
+## Manual Setup
+
+### Prerequisites
+
+- Node.js 18+ (use `nvm use` if you have [nvm](https://github.com/nvm-sh/nvm))
+- Angel One trading account
+- SmartAPI key from [smartapi.angelone.in](https://smartapi.angelone.in/)
+- TOTP authenticator set up on your Angel One account
+
+### 1. Get your credentials
+
+1. Log in to [SmartAPI portal](https://smartapi.angelone.in/)
+2. Create an app to get your **API Key**
+3. Note your **Client ID** (trading account code)
+4. Set up TOTP and save the **Base32 secret** (shown during TOTP setup, not the QR code)
+
+### 2. Install and configure
+
+```bash
+git clone https://github.com/ameernoufil/angel-one-mcp.git
+cd angel-one-mcp
+npm install
+cp .env.example .env
+```
+
+Edit `.env` with your credentials:
+
+```env
+ANGEL_API_KEY=your_smartapi_key
+ANGEL_CLIENT_ID=your_client_id
+ANGEL_PASSWORD=your_mpin
+ANGEL_TOTP_SECRET=your_base32_totp_secret
+```
+
+### 3. Build and run
+
+```bash
+npm run build
+npm start
+```
+
+### 4. Add to your MCP client
+
+Add to your MCP client config (e.g. Claude Desktop, Claude Code, Cursor):
+
+```json
+{
+  "mcpServers": {
+    "angel-one": {
+      "type": "stdio",
+      "command": "node",
+      "args": ["/absolute/path/to/angel-one-mcp/build/index.js"],
+      "env": {
+        "ANGEL_API_KEY": "your_smartapi_key",
+        "ANGEL_CLIENT_ID": "your_client_id",
+        "ANGEL_PASSWORD": "your_mpin",
+        "ANGEL_TOTP_SECRET": "your_base32_totp_secret"
+      }
+    }
+  }
+}
+```
+
+Or if using `.env`, omit the `env` block — the server loads `.env` automatically.
+
+### Safety Limits Configuration
+
+**Soft limits** (bypassable with `force: true`):
+
+| Limit | Default | Env Var |
+|-------|---------|---------|
+| Max order quantity | 25 | `SOFT_MAX_ORDER_QTY` |
+| Max order value | ₹10,000 | `SOFT_MAX_ORDER_VALUE` |
+
+**Hard limits** (env var change + restart):
+
+| Limit | Default | Env Var |
+|-------|---------|---------|
+| Max order quantity | 100 | `HARD_MAX_ORDER_QTY` |
+| Max order value | ₹1,00,000 | `HARD_MAX_ORDER_VALUE` |
+
+### Development
+
+```bash
+npm run dev        # Watch mode
+npm run lint       # ESLint
+npm run lint:fix   # ESLint with auto-fix
+npm run format     # Prettier
+```
+
+## License
+
+[MIT](LICENSE)

package/build/api.d.ts

@@ -0,0 +1,90 @@
+import type { Config } from "./config.js";
+import type { CancelGttRuleParams, CancelOrderParams, ConvertPositionParams, CreateGttRuleParams, ModifyGttRuleParams, ModifyOrderParams, PlaceOrderParams } from "./types.js";
+export declare class AngelOneAPI {
+    private config;
+    private jwtToken;
+    private refreshToken;
+    private feedToken;
+    private tokenExpiry;
+    private loginPromise;
+    constructor(config: Config);
+    private getHeaders;
+    private request;
+    ensureAuthenticated(): Promise<void>;
+    login(): Promise<void>;
+    logout(): Promise<void>;
+    private refreshTokens;
+    private authenticatedRequest;
+    getProfile<T>(): Promise<T | null>;
+    getRMS<T>(): Promise<T | null>;
+    getHoldings<T>(): Promise<T | null>;
+    getPositions<T>(): Promise<T | null>;
+    getOrderBook<T>(): Promise<T | null>;
+    getTradeBook<T>(): Promise<T | null>;
+    placeOrder<T>(params: PlaceOrderParams): Promise<T | null>;
+    modifyOrder<T>(params: ModifyOrderParams): Promise<T | null>;
+    cancelOrder<T>(params: CancelOrderParams): Promise<T | null>;
+    getLtpData<T>(params: {
+        exchange: string;
+        tradingsymbol: string;
+        symboltoken: string;
+    }): Promise<T | null>;
+    searchScrip<T>(params: {
+        exchange: string;
+        searchscrip: string;
+    }): Promise<T | null>;
+    getCandleData<T>(params: {
+        exchange: string;
+        symboltoken: string;
+        interval: string;
+        fromdate: string;
+        todate: string;
+    }): Promise<T | null>;
+    getMarketQuote<T>(params: {
+        mode: string;
+        exchangeTokens: Record<string, string[]>;
+    }): Promise<T | null>;
+    createGttRule<T>(params: CreateGttRuleParams): Promise<T | null>;
+    modifyGttRule<T>(params: ModifyGttRuleParams): Promise<T | null>;
+    cancelGttRule<T>(params: CancelGttRuleParams): Promise<T | null>;
+    getGttRuleDetails<T>(params: {
+        id: string;
+    }): Promise<T | null>;
+    getGttRuleList<T>(params: {
+        status: string[];
+        page: number;
+        count: number;
+    }): Promise<T | null>;
+    getAllHoldings<T>(): Promise<T | null>;
+    convertPosition<T>(params: ConvertPositionParams): Promise<T | null>;
+    getOrderDetails<T>(orderId: string): Promise<T | null>;
+    getOIData<T>(params: {
+        exchange: string;
+        symboltoken: string;
+        interval: string;
+        fromdate: string;
+        todate: string;
+    }): Promise<T | null>;
+    getOptionGreeks<T>(params: {
+        name: string;
+        expirydate: string;
+    }): Promise<T | null>;
+    getGainersLosers<T>(params: {
+        datatype: string;
+        expirytype: string;
+    }): Promise<T | null>;
+    getPutCallRatio<T>(): Promise<T | null>;
+    getOIBuildup<T>(params: {
+        expirytype: string;
+        datatype: string;
+    }): Promise<T | null>;
+    getNseIntraday<T>(): Promise<T | null>;
+    getBseIntraday<T>(): Promise<T | null>;
+    estimateMargin<T>(params: {
+        positions: unknown[];
+    }): Promise<T | null>;
+    estimateCharges<T>(params: {
+        orders: unknown[];
+    }): Promise<T | null>;
+    isAuthenticated(): boolean;
+}

package/build/api.js

@@ -0,0 +1,246 @@
+import { generateTOTP } from "./totp.js";
+import { AngelOneError } from "./types.js";
+const BASE_URL = "https://apiconnect.angelone.in";
+export class AngelOneAPI {
+    config;
+    jwtToken = null;
+    refreshToken = null;
+    feedToken = null;
+    tokenExpiry = 0;
+    loginPromise = null;
+    constructor(config) {
+        this.config = config;
+    }
+    getHeaders(authenticated = false) {
+        const headers = {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            "X-UserType": "USER",
+            "X-SourceID": "WEB",
+            "X-ClientLocalIP": "127.0.0.1",
+            "X-ClientPublicIP": "127.0.0.1",
+            "X-MACAddress": "AA:AA:AA:AA:AA:AA",
+            "X-PrivateKey": this.config.apiKey,
+        };
+        if (authenticated && this.jwtToken) {
+            headers["Authorization"] = `Bearer ${this.jwtToken}`;
+        }
+        return headers;
+    }
+    async request(method, endpoint, body, authenticated = true) {
+        const url = `${BASE_URL}${endpoint}`;
+        const headers = this.getHeaders(authenticated);
+        const options = { method, headers };
+        if (body) {
+            options.body = JSON.stringify(body);
+        }
+        const response = await fetch(url, options);
+        const contentType = response.headers.get("content-type") ?? "";
+        if (!contentType.includes("application/json")) {
+            throw new AngelOneError(`HTTP ${response.status}: ${response.statusText} (non-JSON response)`, "HTTP_ERROR", response.status);
+        }
+        const data = (await response.json());
+        if (!data.status) {
+            throw new AngelOneError(data.message || "API request failed", data.errorcode || "UNKNOWN", response.status);
+        }
+        if (data.data === null || data.data === undefined) {
+            return null;
+        }
+        return data.data;
+    }
+    async ensureAuthenticated() {
+        if (this.jwtToken && Date.now() < this.tokenExpiry - 5 * 60 * 1000) {
+            return;
+        }
+        if (this.jwtToken && this.refreshToken && Date.now() < this.tokenExpiry) {
+            try {
+                await this.refreshTokens();
+                return;
+            }
+            catch {
+                // Refresh failed, fall through to full login
+            }
+        }
+        await this.login();
+    }
+    async login() {
+        if (this.loginPromise) {
+            await this.loginPromise;
+            return;
+        }
+        this.loginPromise = (async () => {
+            try {
+                const totp = generateTOTP(this.config.totpSecret);
+                const data = await this.request("POST", "/rest/auth/angelbroking/user/v1/loginByPassword", {
+                    clientcode: this.config.clientId,
+                    password: this.config.password,
+                    totp,
+                }, false);
+                if (!data) {
+                    throw new AngelOneError("Login succeeded but returned no data", "LOGIN_NO_DATA", 200);
+                }
+                this.jwtToken = data.jwtToken;
+                this.refreshToken = data.refreshToken;
+                this.feedToken = data.feedToken;
+                this.tokenExpiry = Date.now() + 24 * 60 * 60 * 1000;
+            }
+            catch (error) {
+                this.jwtToken = null;
+                this.refreshToken = null;
+                this.feedToken = null;
+                this.tokenExpiry = 0;
+                throw error;
+            }
+            finally {
+                this.loginPromise = null;
+            }
+        })();
+        await this.loginPromise;
+    }
+    async logout() {
+        if (this.jwtToken) {
+            try {
+                await this.request("POST", "/rest/secure/angelbroking/user/v1/logout", {
+                    clientcode: this.config.clientId,
+                }, true);
+            }
+            catch {
+                // Best-effort — clear tokens regardless
+            }
+        }
+        this.jwtToken = null;
+        this.refreshToken = null;
+        this.feedToken = null;
+        this.tokenExpiry = 0;
+    }
+    async refreshTokens() {
+        const data = await this.request("POST", "/rest/auth/angelbroking/jwt/v1/generateTokens", { refreshToken: this.refreshToken }, true);
+        if (!data) {
+            throw new AngelOneError("Token refresh returned no data", "REFRESH_NO_DATA", 200);
+        }
+        this.jwtToken = data.jwtToken;
+        this.refreshToken = data.refreshToken;
+        this.feedToken = data.feedToken;
+        this.tokenExpiry = Date.now() + 24 * 60 * 60 * 1000;
+    }
+    async authenticatedRequest(method, endpoint, body) {
+        await this.ensureAuthenticated();
+        try {
+            return await this.request(method, endpoint, body, true);
+        }
+        catch (error) {
+            if (error instanceof AngelOneError &&
+                (error.errorcode === "AG8001" || error.statusCode === 401)) {
+                this.jwtToken = null;
+                await this.login();
+                return await this.request(method, endpoint, body, true);
+            }
+            throw error;
+        }
+    }
+    // User
+    async getProfile() {
+        return this.authenticatedRequest("GET", "/rest/secure/angelbroking/user/v1/getProfile");
+    }
+    async getRMS() {
+        return this.authenticatedRequest("GET", "/rest/secure/angelbroking/user/v1/getRMS");
+    }
+    // Portfolio
+    async getHoldings() {
+        return this.authenticatedRequest("GET", "/rest/secure/angelbroking/portfolio/v1/getHolding");
+    }
+    async getPositions() {
+        return this.authenticatedRequest("GET", "/rest/secure/angelbroking/order/v1/getPosition");
+    }
+    // Orders
+    async getOrderBook() {
+        return this.authenticatedRequest("GET", "/rest/secure/angelbroking/order/v1/getOrderBook");
+    }
+    async getTradeBook() {
+        return this.authenticatedRequest("GET", "/rest/secure/angelbroking/order/v1/getTradeBook");
+    }
+    async placeOrder(params) {
+        return this.authenticatedRequest("POST", "/rest/secure/angelbroking/order/v1/placeOrder", params);
+    }
+    async modifyOrder(params) {
+        return this.authenticatedRequest("POST", "/rest/secure/angelbroking/order/v1/modifyOrder", params);
+    }
+    async cancelOrder(params) {
+        return this.authenticatedRequest("POST", "/rest/secure/angelbroking/order/v1/cancelOrder", params);
+    }
+    // Market Data
+    async getLtpData(params) {
+        return this.authenticatedRequest("POST", "/rest/secure/angelbroking/order/v1/getLtpData", params);
+    }
+    async searchScrip(params) {
+        return this.authenticatedRequest("POST", "/rest/secure/angelbroking/order/v1/searchScrip", params);
+    }
+    async getCandleData(params) {
+        return this.authenticatedRequest("POST", "/rest/secure/angelbroking/historical/v1/getCandleData", params);
+    }
+    async getMarketQuote(params) {
+        return this.authenticatedRequest("POST", "/rest/secure/angelbroking/market/v1/quote", params);
+    }
+    // GTT
+    async createGttRule(params) {
+        return this.authenticatedRequest("POST", "/gtt-service/rest/secure/angelbroking/gtt/v1/createRule", params);
+    }
+    async modifyGttRule(params) {
+        return this.authenticatedRequest("POST", "/gtt-service/rest/secure/angelbroking/gtt/v1/modifyRule", params);
+    }
+    async cancelGttRule(params) {
+        return this.authenticatedRequest("POST", "/gtt-service/rest/secure/angelbroking/gtt/v1/cancelRule", params);
+    }
+    async getGttRuleDetails(params) {
+        return this.authenticatedRequest("POST", "/rest/secure/angelbroking/gtt/v1/ruleDetails", params);
+    }
+    async getGttRuleList(params) {
+        return this.authenticatedRequest("POST", "/rest/secure/angelbroking/gtt/v1/ruleList", params);
+    }
+    // Extended Portfolio
+    async getAllHoldings() {
+        return this.authenticatedRequest("GET", "/rest/secure/angelbroking/portfolio/v1/getAllHolding");
+    }
+    async convertPosition(params) {
+        return this.authenticatedRequest("POST", "/rest/secure/angelbroking/order/v1/convertPosition", params);
+    }
+    // Individual Order
+    async getOrderDetails(orderId) {
+        if (!/^\d+$/.test(orderId)) {
+            throw new AngelOneError("Invalid orderId: must contain only digits", "INVALID_PARAM", 400);
+        }
+        return this.authenticatedRequest("GET", `/rest/secure/angelbroking/order/v1/details/${orderId}`);
+    }
+    // Market Analytics
+    async getOIData(params) {
+        return this.authenticatedRequest("POST", "/rest/secure/angelbroking/historical/v1/getOIData", params);
+    }
+    async getOptionGreeks(params) {
+        return this.authenticatedRequest("POST", "/rest/secure/angelbroking/marketData/v1/optionGreek", params);
+    }
+    async getGainersLosers(params) {
+        return this.authenticatedRequest("POST", "/rest/secure/angelbroking/marketData/v1/gainersLosers", params);
+    }
+    async getPutCallRatio() {
+        return this.authenticatedRequest("GET", "/rest/secure/angelbroking/marketData/v1/putCallRatio");
+    }
+    async getOIBuildup(params) {
+        return this.authenticatedRequest("POST", "/rest/secure/angelbroking/marketData/v1/OIBuildup", params);
+    }
+    async getNseIntraday() {
+        return this.authenticatedRequest("GET", "/rest/secure/angelbroking/marketData/v1/nseIntraday");
+    }
+    async getBseIntraday() {
+        return this.authenticatedRequest("GET", "/rest/secure/angelbroking/marketData/v1/bseIntraday");
+    }
+    // Calculator
+    async estimateMargin(params) {
+        return this.authenticatedRequest("POST", "/rest/secure/angelbroking/margin/v1/batch", params);
+    }
+    async estimateCharges(params) {
+        return this.authenticatedRequest("POST", "/rest/secure/angelbroking/brokerage/v1/estimateCharges", params);
+    }
+    isAuthenticated() {
+        return this.jwtToken !== null && Date.now() < this.tokenExpiry;
+    }
+}

package/build/config.d.ts

@@ -0,0 +1,15 @@
+export interface SafetyConfig {
+    softMaxOrderQty: number;
+    hardMaxOrderQty: number;
+    softMaxOrderValue: number;
+    hardMaxOrderValue: number;
+}
+export interface Credentials {
+    apiKey: string;
+    clientId: string;
+    password: string;
+    totpSecret: string;
+}
+export interface Config extends Credentials, SafetyConfig {
+}
+export declare function loadConfig(): Config;

package/build/config.js

@@ -0,0 +1,42 @@
+export function loadConfig() {
+    const apiKey = process.env.ANGEL_API_KEY;
+    const clientId = process.env.ANGEL_CLIENT_ID;
+    const password = process.env.ANGEL_PASSWORD;
+    const totpSecret = process.env.ANGEL_TOTP_SECRET;
+    if (!apiKey || !clientId || !password || !totpSecret) {
+        const missing = [
+            !apiKey && "ANGEL_API_KEY",
+            !clientId && "ANGEL_CLIENT_ID",
+            !password && "ANGEL_PASSWORD",
+            !totpSecret && "ANGEL_TOTP_SECRET",
+        ].filter(Boolean);
+        throw new Error(`Missing required env vars: ${missing.join(", ")}`);
+    }
+    const parseIntSafe = (name, val, fallback) => {
+        if (!val)
+            return fallback;
+        const parsed = Math.floor(Number(val));
+        if (!Number.isFinite(parsed) || parsed <= 0) {
+            process.stderr.write(`Warning: invalid value "${val}" for ${name}, using default ${fallback}\n`);
+            return fallback;
+        }
+        return parsed;
+    };
+    const config = {
+        apiKey,
+        clientId,
+        password,
+        totpSecret,
+        softMaxOrderQty: parseIntSafe("SOFT_MAX_ORDER_QTY", process.env.SOFT_MAX_ORDER_QTY, 25),
+        hardMaxOrderQty: parseIntSafe("HARD_MAX_ORDER_QTY", process.env.HARD_MAX_ORDER_QTY, 100),
+        softMaxOrderValue: parseIntSafe("SOFT_MAX_ORDER_VALUE", process.env.SOFT_MAX_ORDER_VALUE, 10000),
+        hardMaxOrderValue: parseIntSafe("HARD_MAX_ORDER_VALUE", process.env.HARD_MAX_ORDER_VALUE, 100000),
+    };
+    if (config.softMaxOrderQty > config.hardMaxOrderQty) {
+        throw new Error(`SOFT_MAX_ORDER_QTY (${config.softMaxOrderQty}) must be ≤ HARD_MAX_ORDER_QTY (${config.hardMaxOrderQty})`);
+    }
+    if (config.softMaxOrderValue > config.hardMaxOrderValue) {
+        throw new Error(`SOFT_MAX_ORDER_VALUE (${config.softMaxOrderValue}) must be ≤ HARD_MAX_ORDER_VALUE (${config.hardMaxOrderValue})`);
+    }
+    return config;
+}

package/build/guards.d.ts

@@ -0,0 +1,7 @@
+import type { SafetyConfig } from "./config.js";
+export interface GuardResult {
+    allowed: boolean;
+    error?: string;
+    warning?: string;
+}
+export declare function validateOrderLimits(config: SafetyConfig, qty: number, price: number | null, force: boolean): GuardResult;

package/build/guards.js

@@ -0,0 +1,46 @@
+export function validateOrderLimits(config, qty, price, force) {
+    if (!Number.isFinite(qty) || qty <= 0) {
+        return { allowed: false, error: `Invalid quantity: must be a finite positive number` };
+    }
+    if (qty > config.hardMaxOrderQty) {
+        return {
+            allowed: false,
+            error: `HARD LIMIT: Quantity ${qty} exceeds maximum ${config.hardMaxOrderQty}. Change HARD_MAX_ORDER_QTY env var to increase.`,
+        };
+    }
+    if (price !== null) {
+        if (!Number.isFinite(price) || price <= 0) {
+            return { allowed: false, error: `Invalid price: must be a finite positive number` };
+        }
+        const value = qty * price;
+        if (value > config.hardMaxOrderValue) {
+            return {
+                allowed: false,
+                error: `HARD LIMIT: Order value ₹${value.toLocaleString("en-IN")} (${qty} × ₹${price}) exceeds maximum ₹${config.hardMaxOrderValue.toLocaleString("en-IN")}. Change HARD_MAX_ORDER_VALUE env var to increase.`,
+            };
+        }
+    }
+    if (!force) {
+        if (qty > config.softMaxOrderQty) {
+            return {
+                allowed: false,
+                error: `Quantity ${qty} exceeds soft limit ${config.softMaxOrderQty}. Pass force: true to override, or change SOFT_MAX_ORDER_QTY env var.`,
+            };
+        }
+        if (price !== null) {
+            const value = qty * price;
+            if (value > config.softMaxOrderValue) {
+                return {
+                    allowed: false,
+                    error: `Order value ₹${value.toLocaleString("en-IN")} (${qty} × ₹${price}) exceeds soft limit ₹${config.softMaxOrderValue.toLocaleString("en-IN")}. Pass force: true to override, or change SOFT_MAX_ORDER_VALUE env var.`,
+                };
+            }
+        }
+    }
+    return {
+        allowed: true,
+        ...(price === null && {
+            warning: "MARKET order: value-based safety limits cannot be enforced without a known price. Only quantity limits applied.",
+        }),
+    };
+}

package/build/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "dotenv/config";

package/build/index.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import "dotenv/config";
+import { readFileSync } from "node:fs";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { AngelOneAPI } from "./api.js";
+import { loadConfig } from "./config.js";
+import { registerAllTools } from "./tools/index.js";
+const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
+const config = loadConfig();
+const api = new AngelOneAPI(config);
+const safetyConfig = {
+    softMaxOrderQty: config.softMaxOrderQty,
+    hardMaxOrderQty: config.hardMaxOrderQty,
+    softMaxOrderValue: config.softMaxOrderValue,
+    hardMaxOrderValue: config.hardMaxOrderValue,
+};
+const server = new McpServer({
+    name: "angel-one",
+    version: pkg.version,
+});
+registerAllTools(server, api, safetyConfig);
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/build/tools/auth.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { AngelOneAPI } from "../api.js";
+export declare function registerAuthTools(server: McpServer, api: AngelOneAPI): void;