Indian Broker MCP Server
Provides integration with the Zerodha Kite platform for read-only portfolio data including stock holdings, F&O positions, mutual funds (via Coin), and order history.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Indian Broker MCP ServerWhat are my current holdings?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Indian Broker MCP Server
A Model Context Protocol (MCP) server that connects to Indian broker platforms — Groww, Zerodha Kite, and INDmoney — to provide a unified, read-only view of your financial portfolio through Claude Code, Claude Desktop, or any MCP-compatible client.
No paid broker API subscriptions required. The server uses Playwright browser automation to capture data from the broker web apps after you log in via a visible Chrome window.
Features
Unified portfolio view across multiple brokers
Stocks, F&O, Mutual Funds, US Stocks, Gold — all asset classes
Network interception captures structured JSON from broker SPAs (more reliable than DOM scraping)
Persistent browser sessions — log in once per session expiry
Encrypted session storage (AES-256-GCM) in memory
Read-only — no order placement, no fund transfers
Graceful degradation — partial data returned if one broker fails
Broker Support Matrix
Feature | Groww | Zerodha Kite | INDmoney |
Stock Holdings | Yes | Yes | Yes |
F&O Positions | Yes | Yes | — |
Mutual Funds | Yes | Yes (Coin) | Yes |
US Stocks | Yes | — | Yes |
Gold / SGB | Yes | — | Yes |
Orders | Yes | Yes | Yes |
Login Method | Email + OTP | User ID + Password + TOTP | Phone + OTP |
Related MCP server: Groww MCP Server
Prerequisites
Node.js 18+
Google Chrome installed (Playwright uses your system Chrome via
channel: 'chrome')Claude Code or Claude Desktop (or any MCP client)
Installation
git clone <repo-url> indian-broker-mcp
cd indian-broker-mcp
npm install
npx playwright install chromium
npm run buildConfiguration
Copy the example env file and edit as needed:
cp .env.example .envEnvironment Variables
Variable | Default | Description |
| Auto-generated | 32-byte hex key for AES-256-GCM session encryption |
|
| Session expiry time in hours |
|
| Set |
|
| Delay in ms between Playwright actions (helps avoid detection) |
|
| Persistent browser profile storage |
|
|
|
|
| Output directory for |
Connecting to an MCP Client
Claude Code
claude mcp add indian-broker -- node /path/to/indian-broker-mcp/build/index.jsClaude Desktop
Add to your Claude Desktop config (~/.config/claude/claude_desktop_config.json on Linux, ~/Library/Application Support/Claude/claude_desktop_config.json on macOS):
{
"mcpServers": {
"indian-broker": {
"command": "node",
"args": ["/path/to/indian-broker-mcp/build/index.js"]
}
}
}Restart Claude Desktop after adding the configuration.
MCP Inspector (for testing)
npx @modelcontextprotocol/inspector node ./build/index.jsOpens a web UI at http://localhost:5173 where you can call tools interactively.
Usage
Step 1: Connect to a broker
Ask Claude:
"Connect me to Zerodha"
This calls the broker_connect tool, which:
Opens a visible Chrome window to the broker's login page
You log in manually (including OTP / 2FA)
The server detects login success automatically and captures the session
You can also connect using cookies from your browser's DevTools:
"Connect to Groww using these cookies:
<paste from document.cookie>"
Step 2: Query your portfolio
Once connected, ask naturally:
"What are my stock holdings?"
"Show my mutual fund portfolio across all brokers"
"What's my total portfolio value?"
"Show my F&O positions on Zerodha"
"What US stocks do I hold?"
"Show today's orders"
"Search for Reliance stock"
Step 3: Disconnect
"Disconnect from Zerodha"
This wipes the session data and deletes the browser profile for that broker.
Tools Reference
Authentication
Tool | Parameters | Description |
|
| Connect to a broker |
|
| Disconnect and wipe session |
| — | Show connection status for all brokers |
Portfolio (Read-Only)
Tool | Parameters | Description |
|
| Stock holdings |
|
| Open positions (intraday/delivery) |
|
| F&O positions specifically |
|
| Mutual fund portfolio |
|
| US stock holdings |
|
| Gold / SGB / Gold ETF holdings |
|
| Today's order history |
| — | Aggregated summary across all brokers |
Market Data
Tool | Parameters | Description |
|
| Search for stocks/MFs by name or symbol |
|
| Current price quote for a stock |
Development
Tool | Parameters | Description |
|
| Record browser navigation, XHR requests, and DOM snapshots for building/updating scrapers |
Resources
MCP Resources provide cached data accessible by URI:
URI | Description |
| Connection status for all brokers |
| Holdings for a specific broker (e.g., |
| Mutual funds for a specific broker |
| Aggregated portfolio summary |
Architecture
MCP Client (Claude Code / Desktop)
│
│ STDIO (JSON-RPC)
▼
┌─────────────────────────────────┐
│ MCP Server (Node.js) │
│ │
│ ┌─────────┐ ┌───────┐ ┌─────┐ │
│ │ Groww │ │Zerodha│ │ IND │ │
│ │ Adapter │ │Adapter│ │money│ │
│ └────┬─────┘ └───┬───┘ └──┬──┘ │
│ │ │ │ │
│ ┌────▼───────────▼────────▼──┐ │
│ │ Playwright (Chrome) │ │
│ │ • Network interception │ │
│ │ • Page navigation │ │
│ │ • Persistent contexts │ │
│ └────────────────────────────┘ │
│ │
│ ┌────────────────────────────┐ │
│ │ Session Store (encrypted) │ │
│ └────────────────────────────┘ │
└─────────────────────────────────┘How data extraction works
Navigate to the relevant broker page (e.g., holdings dashboard)
Intercept the XHR/fetch responses the SPA makes to its internal APIs
Parse the structured JSON from those responses
Normalize broker-specific fields into unified types
Return to the MCP client in a consistent format
Network interception is the primary strategy because it captures clean, structured data directly from the broker's internal APIs — far more reliable than parsing the DOM.
Project Structure
src/
├── index.ts # Entry point (STDIO transport)
├── server.ts # MCP server, tool/resource registration
├── types/
│ ├── portfolio.ts # Holding, Position, MutualFundHolding, etc.
│ ├── broker.ts # BrokerAdapter interface
│ └── auth.ts # Session types
├── adapters/
│ ├── base.ts # Abstract base adapter
│ ├── groww/
│ │ ├── index.ts # Adapter + normalizers
│ │ ├── scraper.ts # Network interception logic
│ │ ├── endpoints.ts # URL patterns
│ │ ├── selectors.ts # DOM selectors (fallback)
│ │ └── types.ts # Raw API response types
│ ├── zerodha/ # Same structure
│ └── indmoney/ # Same structure
├── browser/
│ ├── manager.ts # Browser lifecycle, persistent contexts
│ ├── auth-flow.ts # Login detection + session capture
│ ├── interceptor.ts # XHR/fetch response capture engine
│ ├── recorder.ts # Navigation recorder for development
│ └── helpers.ts # Utilities (delays, screenshots)
├── auth/
│ ├── crypto.ts # AES-256-GCM encrypt/decrypt
│ └── session-store.ts # In-memory encrypted session store
├── normalizer/
│ └── index.ts # Portfolio summary aggregation
└── utils/
├── logger.ts # stderr-only logger
├── config.ts # .env config loader
└── retry.ts # Exponential backoff retrySession Management
Sessions are stored encrypted in memory using AES-256-GCM
Browser profiles are persisted to disk under
browser-data/{broker}/so cookies survive server restartsSessions auto-expire after the configured TTL (default: 6 hours)
When a session expires, the next data request will return an error prompting you to reconnect
broker_disconnectsecurely wipes both the in-memory session and the on-disk browser profileEach broker is fully isolated in its own browser context
Typical session lifetimes
Broker | Approximate Session Duration |
Zerodha Kite | 6–8 hours |
Groww | Varies |
INDmoney | Days to weeks |
Development
Adding or updating broker scrapers
The learn_broker_navigation tool helps you discover and update internal API endpoints:
Call the tool:
learn_broker_navigationwithbroker: "groww"A Chrome window opens — log in and navigate to the pages you care about
The recorder captures every URL, XHR request/response, and DOM state
Recordings are saved to
recordings/{broker}/{timestamp}/Use the captured data to update
endpoints.tsandtypes.tsfor that broker
Watch mode
npm run dev # tsc --watchKey design decisions
Network interception over DOM scraping: Broker SPAs fetch data via internal REST APIs. Intercepting those JSON responses is more reliable and structured than parsing rendered HTML.
Persistent browser contexts: Using Playwright's
launchPersistentContextso cookies/localStorage survive restarts. The user only needs to log in when the session expires.Anti-detection: Uses real Chrome (not Chromium), removes
webdriverflag, adds random delays between actions.Flexible response parsing: Each adapter's normalizer handles multiple possible response shapes (brokers may change their API structure). Fields are accessed with fallback chains (
raw.field1 ?? raw.field2 ?? default).
Security
No credentials stored — you log in manually; only session cookies are captured
AES-256-GCM encryption for all in-memory session data
Cookies and tokens are never logged — the logger redacts sensitive data
All output goes to stderr — stdout is reserved for MCP JSON-RPC (writing to stdout would break the protocol)
Browser profiles are gitignored and deleted on disconnect
Strictly read-only — there are no tools for placing orders, modifying positions, or transferring funds
Limitations
Browser scraping is fragile — broker UIs and internal APIs change without notice. Use
learn_broker_navigationto recalibrate when something breaks.OTP login requires user presence — Groww and INDmoney require manual OTP entry. Zerodha requires TOTP/PIN.
No real-time streaming — data is fetched on demand by navigating to pages. There is no WebSocket or live price feed.
Rate limiting — avoid calling portfolio tools in rapid succession. The server adds delays between page navigations but aggressive use may trigger broker anti-bot measures.
Terms of Service — automated access to broker web apps may violate their terms. This tool is intended for personal use only.
Single user — the server manages one session per broker. It is not designed for multi-user or shared access.
License
MIT
Available Tools
14 toolsbroker_connectC
Connect to an Indian broker by opening a browser for login
| Name | Required | Description | Default |
|---|---|---|---|
| broker | Yes | ||
| method | No | browser_login | |
| cookies | No | Raw cookie string if method is 'cookies' |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full behavioral burden. It only discloses that a browser is opened for login, but omits the cookies method, potential need for user interaction, and post-login session behavior, making it insufficiently transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that efficiently conveys the main action with no wasted words. While it omits details, that is a completeness concern, not a conciseness issue.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no annotations, no output schema, and low schema coverage, the description leaves significant gaps: it does not explain the cookies method, prerequisites, return behavior, or when browser interaction is required. This is inadequate for a 3-parameter tool in a broker workflow.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 33% (only cookies has a description). The description adds no parameter-level meaning, failing to explain the broker enum or the method parameter, and does not compensate for the low schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool connects to an Indian broker, a specific verb and resource, and distinguishes it from sibling tools like broker_disconnect and broker_status. The appended 'by opening a browser for login' is accurate for the default method and does not obscure the core purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as broker_status or broker_disconnect. The description only implies usage for connecting, without explicit context or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
broker_disconnectA
Disconnect from a broker and wipe session data
| Name | Required | Description | Default |
|---|---|---|---|
| broker | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses the destructive side effect of wiping session data, which is crucial given the absence of annotations. However, it does not elaborate on broader consequences, such as impacted orders or token invalidation, which could be important for the agent to know.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that front-loads the action and notes the side effect. It contains no redundant information and is immediately scannable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter tool with no output schema or annotations, the description covers the core action and side effect. It lacks details on return values or error conditions, but those are less critical for a disconnect operation, and the sibling tools provide enough context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has a single 'broker' parameter with an enum, and the description does not add specific semantic meaning beyond the schema. It mentions 'a broker' in general terms but does not explicitly tie the parameter to the action or describe selection implications, failing to compensate for the 0% schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the verb 'disconnect' and identifies the resource as 'a broker', clearly distinguishing it from sibling tools like broker_connect and broker_status. The additional phrase 'wipe session data' further clarifies the scope of the operation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no explicit guidance on when to use this tool or when not to. It does not mention that it is the inverse of broker_connect or that it should be used when ending a broker session, leaving usage to be inferred.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
broker_statusA
Show connection status for all brokers
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must fully disclose behavioral traits. It only says 'Show connection status' which implies a read-only operation but provides no details on return format, required authentication, or any side effects. This is insufficient for an agent to understand the tool's behavior beyond the surface-level action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, completely free of redundancy. It states the purpose efficiently without wasted words, making it easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (zero parameters, no annotations, no output schema), the description adequately conveys the essential purpose. It could benefit from indicating what kind of statuses are returned, but for a status-check tool, 'connection status' is reasonably self-explanatory.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Since the tool has zero parameters, the schema is empty. The description adds meaning by clarifying the scope ('for all brokers'), which is relevant to the absence of parameters. Per the rubric, a baseline of 4 is appropriate for tools with no parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Show connection status for all brokers' with a specific verb 'Show' and a specific resource. It distinguishes from sibling tools like broker_connect and broker_disconnect, which are about establishing and terminating connections.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The description does not mention any context, prerequisites, or exclusion conditions. It simply states what the tool does without helping the agent decide between this and the connection management tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_fno_positionsC
Fetch F&O positions from connected brokers
| Name | Required | Description | Default |
|---|---|---|---|
| broker | No | all |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits itself. 'Fetch' implies a read operation, but the description does not explicitly state that it is read-only, whether it touches all brokers by default, or any other behaviors. The minimal text provides little beyond the verb.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence with no wasted words. It places the verb at the start and is appropriately short for such a simple tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite being a simple tool with one optional parameter and no output schema, the description is too scant. It fails to explain the broker parameter, differentiate from the broader get_positions tool, or clarify what the agent should expect in the response. More context is needed for reliable tool selection.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has one parameter 'broker' with an enum but no description (0% schema description coverage). The description does not mention the broker parameter at all, leaving the agent without any explanation of how to filter results or what the default behavior is.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Fetch' and identifies the resource 'F&O positions' from 'connected brokers', making the tool's purpose clear. It is more specific than siblings like get_positions, though it doesn't explicitly distinguish between them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The usage is implied by the tool name and description: use this when you need F&O (derivatives) positions. However, there is no explicit guidance on when to use this versus alternatives like get_positions, or any conditions or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_goldA
Fetch gold holdings from connected brokers
| Name | Required | Description | Default |
|---|---|---|---|
| broker | No | all |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden. It does disclose the prerequisite of connected brokers and the read-only nature of 'Fetch', but it does not describe what happens if no brokers are connected or other failure modes. This gives partial transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that wastes no words. It effectively states the tool's purpose without extraneous detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with only one enum parameter and no output schema, the description provides sufficient context. It names the resource and the prerequisite of connected brokers, which covers the essential use case. It does not mention return format, but that is not required when output schema is absent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not explain the 'broker' parameter at all. Although the enum values are self-explanatory and a default exists, the description should have compensated for the lack of schema coverage but does not.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb (Fetch) and names the resource (gold holdings) along with the scope (from connected brokers). It clearly distinguishes itself from sibling tools like get_holdings and get_mutual_funds by specifying 'gold'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for retrieving gold holdings, but it does not explicitly state when to prefer this over the more general get_holdings, nor does it mention any exclusions or alternatives. The context is implied rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_holdingsC
Fetch stock holdings from connected brokers
| Name | Required | Description | Default |
|---|---|---|---|
| broker | No | all |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'connected brokers' but does not explain behavior when no broker is connected, whether holdings are aggregated across brokers, or any permission/error scenarios. Minimal context is added beyond the basic function.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with no filler, front-loading the action and resource. It earns its place structurally, though it is too terse to cover necessary semantics.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has one optional parameter and no output schema, yet the description is only a short phrase. It does not describe return shape, error cases, or how broker filtering works, leaving significant gaps for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description does not mention the 'broker' parameter at all. With 0% schema description coverage, the description should compensate by explaining how broker selection and the 'all' default work, but it provides no parameter semantics beyond what the enum values themselves imply.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Fetch') and resource ('stock holdings') with a source ('connected brokers'), clearly stating what the tool does. It distinguishes from siblings like get_orders or get_mutual_funds, though get_positions could overlap and is not explicitly differentiated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus get_positions or get_portfolio_summary, nor are prerequisites such as a successful broker connection mentioned. Usage is only implied by the tool's name and minimal description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_mutual_fundsB
Fetch mutual fund holdings from connected brokers
| Name | Required | Description | Default |
|---|---|---|---|
| broker | No | all |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries full behavioral disclosure burden. 'Fetch' implies a read-only operation, but no details are given about return format, error handling, rate limits, or authentication requirements. 'Connected brokers' hints at a prerequisite but does not explain behaviors.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that is front-loaded and efficient. Every word earns its place, with no redundancy or irrelevant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema and no annotations, the description fails to explain return values or usage nuances. It is minimally sufficient for a simple read operation but lacks completeness regarding response structure and operational context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description does not mention the 'broker' parameter at all. While the schema's enum and default provide some clarity, schema description coverage is 0%, and the description adds no semantic value beyond what the schema already offers.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool fetches mutual fund holdings, using a specific verb and resource. It distinguishes from sibling tools like get_holdings (general) and get_us_stocks/gold by specifying 'mutual fund'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like get_holdings. The phrase 'from connected brokers' implies a prerequisite but does not explain when this tool is preferred or what to do if brokers are not connected.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_ordersB
Fetch today's order history from connected brokers
| Name | Required | Description | Default |
|---|---|---|---|
| broker | No | all |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full responsibility for behavioral disclosure. The description only states the action and scope; it does not mention read-only nature, error handling for disconnected brokers, or response format. This is a significant gap for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that is front-loaded with the action and resource. Every word is purposeful, with no redundancy or fluff. It is appropriately sized for a simple tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no annotations, no output schema, and only one parameter, the description is too minimal to provide complete context. It lacks guidance on usage, behavioral traits, and parameter semantics. The description is enough to convey the basic purpose but not the necessary surrounding context for an agent to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has one parameter 'broker' with enum values but zero description coverage. The tool description does not explain how this parameter affects the result, such as filtering by specific broker or defaulting to 'all'. The phrase 'connected brokers' loosely relates to the parameter but adds no meaningful semantics beyond the schema's enum values.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Fetch' with a clear resource 'today's order history' and scope 'from connected brokers'. It clearly distinguishes itself from sibling tools like get_holdings and get_positions by focusing on order history.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context (requires connected brokers, fetches orders for today) but provides no explicit guidance on when to use this tool versus alternatives like get_positions or get_portfolio_summary. No exclusions or alternative tool mentions are present.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_portfolio_summaryB
Aggregated portfolio summary across all connected brokers
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must handle full behavioral context. It mentions 'aggregated' and 'across all connected brokers', suggesting data is combined, but it does not disclose whether the operation is read-only, whether it requires existing broker connections, or whether the summary is real-time vs delayed. This leaves significant ambiguity for an agent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise phrase that conveys the essential scope ('across all connected brokers') without any filler. It is front-loaded and every word contributes meaning, making it highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
There is no output schema, so the description should clarify what the summary contains (e.g., total value, asset allocation, per-broker breakdown). The current wording is too vague for an agent to know what response to expect or how to interpret the result, making the tool under-specified for practical use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so the description has no need to explain parameter meaning. The schema coverage is effectively 100% (vacuously), and the description does not add unnecessary detail. Consequently, this dimension is at the baseline for a no-parameter tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Aggregated portfolio summary across all connected brokers' clearly indicates a read operation that returns a consolidated view of the user's total portfolio, distinguishing it from more specific sibling tools like get_holdings or get_positions. The lack of an explicit verb is compensated by the tool name starting with 'get'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies this tool is for obtaining a high-level overview across all brokers, but it does not explicitly state when to use it versus alternatives like get_holdings or get_mutual_funds. There is no mention of when not to use it or which sibling tools to prefer for detailed breakdowns.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_positionsC
Fetch open positions from connected brokers
| Name | Required | Description | Default |
|---|---|---|---|
| broker | No | all |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full responsibility for behavioral disclosure. It mentions 'connected brokers' but does not explain what happens if none are connected, the meaning of the default 'all', or any limitations. The non-mutating nature is implied by 'Fetch' but never explicitly stated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, focused sentence that front-loads the action and resource. There is no wasted content, and it is appropriately concise for the tool's simplicity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity and lack of output schema, the description is adequate but leaves gaps. It does not clarify whether 'positions' includes F&O (given the get_fno_positions sibling), how the default 'all' behaves, or what the response structure looks like. These are notable omissions for an agent selecting the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not explain the 'broker' parameter beyond what the schema's enum and default already show. The schema is self-explanatory for a simple parameter, but the description adds no value in clarifying how the broker selection affects the returned data.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a clear action ('Fetch'), resource ('open positions'), and scope ('from connected brokers'). It distinguishes from siblings like get_holdings and get_orders, but does not explicitly contrast with get_fno_positions, leaving ambiguity about whether positions include derivatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description offers no guidance on when to use this tool versus alternatives like get_fno_positions or get_holdings. It also does not mention prerequisites, such as ensuring brokers are connected, or scenarios where another tool would be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_quoteC
Get current price quote for a stock
| Name | Required | Description | Default |
|---|---|---|---|
| broker | No | ||
| symbol | Yes | Stock symbol (e.g., RELIANCE) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full responsibility for behavioral disclosure. It only states 'current price quote' but omits important traits like whether the quote is real-time or delayed, whether it depends on broker availability, or if any side effects occur.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with no filler words. It is appropriately short for a straightforward tool, prioritizing clarity over verbosity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given there is no output schema and the tool has two parameters, the description should explain return values and broker semantics. It provides only minimal information, leaving the agent uncertain about how to invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 50% (symbol is described, broker is not). The description adds no extra meaning for the broker parameter, which is crucial for selecting the brokerage. It does not compensate for the lack of schema documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Get current price quote for a stock' with a specific verb and resource. However, it does not differentiate this from sibling tools like get_us_stocks or get_gold, which may also return quotes for different asset types.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. It does not mention broker context, whether it requires a connected broker, or how it differs from other quote-related tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_us_stocksB
Fetch US stock holdings from connected brokers
| Name | Required | Description | Default |
|---|---|---|---|
| broker | No | all |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description alone must disclose behavior. It only states that data comes from connected brokers, but does not describe return format, aggregation across brokers, error behavior, or any side effects. This is a significant gap for a tool with no annotation support.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no wasted words. It states the verb, resource, and source efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only holdings tool, the core purpose is clear, but without an output schema or annotations, the description does not specify what a returned holding includes (symbol, quantity, etc.) or the behavior when no brokers are connected. It is minimally viable but lacks completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description does not mention the 'broker' parameter at all, and schema description coverage is 0%. Although the schema's enum values and default are self-explanatory, the description fails to compensate or add any meaning beyond the structured schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'Fetch' with the resource 'US stock holdings' and source 'connected brokers', making the tool's purpose unambiguous. It clearly distinguishes this from sibling tools like get_holdings, get_mutual_funds, or get_gold by restricting to US stocks.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance is given about when to choose this tool over alternatives such as get_holdings or get_positions. The 'US stock holdings' phrasing implies a use case, but no prerequisites, exclusions, or alternative comparisons are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_stockB
Search for a stock or mutual fund by name or symbol
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query (stock name or symbol) | |
| broker | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations are absent, so the description carries full burden. It discloses only the search action and criteria, but nothing about result format, pagination, ranking, or potential limitations. This is minimal and not contradictory, but insufficient for an agent to anticipate the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, front-loaded sentence with no excess words. It communicates the essential purpose clearly and efficiently, earning its place without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and no annotations, the description is too sparse. It does not indicate whether the response is a list or single match, how results are ranked, or how this tool fits into a broker interaction workflow. This is a minimal viable description but not complete enough for confident use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 50%: only 'query' has a description, while 'broker' has none. The tool description does not explain the broker parameter or when/how to use it. 'By name or symbol' merely restates the query description, adding no new semantic value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Search for a stock or mutual fund by name or symbol.' It uses a specific verb (search) and resource (stock or mutual fund), and differentiates from siblings like get_quote or get_holdings by focusing on discovery rather than retrieval.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives. It does not mention when to search vs. directly fetching a quote or holdings, nor does it specify any exclusions or prerequisites. Usage is only implied by the term 'search'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
14 tool updates
v1.0.0- First observed
broker_connect - First observed
broker_disconnect - First observed
broker_status - First observed
get_fno_positions - First observed
get_gold - First observed
get_holdings - First observed
get_mutual_funds - First observed
get_orders - First observed
get_portfolio_summary - First observed
get_positions - First observed
get_quote - First observed
get_us_stocks - First observed
learn_broker_navigation - First observed
search_stock
TDQS
Scored across 14 tools
Most tools have clearly distinct purposes, but get_positions and get_fno_positions could be confused since F&O positions are a subset of positions. Similarly, get_holdings, get_mutual_funds, get_us_stocks, and get_gold are differentiated by asset type, which is clear. Overall, the tools are separable by their descriptions.
The naming convention is mixed: some tools follow a verb_noun pattern (e.g., get_holdings, search_stock), while others use a noun_verb pattern (e.g., broker_connect, broker_disconnect). This inconsistency is not chaotic but could be more uniform. Both patterns use lowercase with underscores, so it's readable.
14 tools is appropriate for a broker aggregation server. The count is well within the typical 3-15 range, and each tool addresses a specific aspect of broker connectivity, data retrieval, or usability. None feel redundant.
The tool set covers connection management, holdings, positions, and orders, but misses obvious financial data like cash balances and trade history. It also lacks any trading or order placement capabilities, which could be expected for a broker MCP, though it may be intentionally read-only. The core read-only aggregation surface is present, but notable gaps exist.
Maintenance
Related MCP Connectors
Stocks, crypto, FX, and portfolio math in one tool — no per-source API juggling.
Open-source MCP server for Zerodha Kite Connect. Portfolio, market data, backtesting, alerts.
Brazilian Open Finance MCP — 30+ banks (Itaú, Nubank, etc.) to Claude/Cursor. Read-only.
Read-only access to your bank, investment, and crypto accounts: balances, transactions, holdings.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceEnables AI-powered trading and portfolio management through Upstox API integration. Supports portfolio rebalancing strategies with LLM inference for automated trading decisions.-
- AlicenseNot gradedqualityDmaintenanceEnables interaction with the Groww trading platform to fetch portfolio data, get live stock quotes and historical market data, and place, modify, or cancel stock orders through natural language commands.10 npm9MIT
- FlicenseNot gradedqualityDmaintenanceIntegrates Interactive Brokers and TradeStation APIs for portfolio management, market data, and trading operations, with TradingView market scanning.-
- AlicenseNot gradedqualityCmaintenanceConsolidates your B3 investment portfolio (stocks, FIIs, fixed income, etc.) from all brokerages into one view. Provides read-only tools to check position, dividends, transactions, and more.MIT