TakeProfit.com MCP

Fetch full or partial chapters from the official TakeProfit documentation: https://takeprofit.com/docs

Documentation covers:
- TakeProfit: a trading platform
- Indie: a language for building technical analysis indicators

Use only when doc_id is already known.
Resolve doc_id first with:
- GetIndieDocsTOC / SearchIndieDocs for Indie docs
- GetPlatformDocsTOC / SearchPlatformDocs for TakeProfit platform docs

PARAMETERS:
- documents: up to 10 items, each with:
- doc_id: document ID from the documentation index (required)
- offset: start character offset (default: 0)
- limit: max characters to return (optional; if omitted, returns all content from offset)

RETURNS per doc_id:
- content: requested text chunk
- total_length: full document length in characters
- offset: offset used
- returned: number of characters returned
- has_more: whether more content remains after this chunk
- error: returned if doc_id is not found

RULES:
- Do not invent doc_id values
- offset beyond document length returns empty content
- if limit exceeds remaining length, content is returned up to the end
- use offset + limit to read large documents in chunks

Return the table of contents for Indie documentation.

Indie is a language for building technical analysis indicators.

Use this tool to discover available docs before reading chapters with GetDocsChapters.
Each entry includes:
- id: document ID
- description: brief summary
- total_length: document size in characters

Guidance:
- Use this before GetDocsChapters when doc_id is not yet known
- Prefer this before writing Indie code, since Indie is not standard Python
- Large documents may be better read in chunks

No parameters.

Return the table of contents for TakeProfit platform documentation.

TakeProfit is a trading platform.
Use this tool to discover platform docs and resolve doc_id values for GetDocsChapters.

Each entry includes:
- id: document ID
- description: brief summary
- total_length: document size in characters

Use for platform topics such as alerts, widgets, webhooks, integrations, and other platform features.

Do not use this tool for precise Indie language information.
For accurate Indie syntax, semantics, constraints, or coding guidance, use
Indie-specific documentation tools or the official docs: https://takeprofit.com/docs

Rules:
- Use this before GetDocsChapters if doc_id is unknown
- Do not invent doc_id values

No parameters.

Search Indie documentation by exact text or regex, similar to grep.

Official documentation: https://takeprofit.com/docs

Indie is a language for building technical analysis indicators.
Use this tool when semantic search is not enough and you need exact matches
for syntax, identifiers, code fragments, patterns, or occurrence counts.

Best for:
- exact code or symbol lookup
- regex-based pattern search
- counting matches
- finding which files contain a pattern
- retrieving local line context around a match

PARAMETERS:
- pattern: literal text or regex pattern
- extended: use extended regex
- fixed: treat pattern as a literal string
- ignore_case: case-insensitive search
- word: match whole words only
- line: match whole lines only
- mode: normal, count, or files
- max_count: stop after N matches per file
- context: lines before and after each match
- before_context: lines before each match
- after_context: lines after each match
- include: include files by glob pattern
- exclude: exclude files by glob pattern
- only_matching: return only the matched fragment
- line_number: include line numbers
- with_filename: include file names
- max_results: total result limit

RETURNS:
- normal mode: matches with file, line, text, optional context, and document offsets
- count mode: match counts
- files mode: files containing matches

GUIDANCE:
- Prefer this for exact lookups; prefer semantic search for conceptual questions
- Use file or character_offset with GetDocsChapters to read the full source context
- Use fixed=true for literal strings when regex is not needed

Runs Indie indicator code on the actual runtime to verify it doesn't crash.

Submits the indicator to the backend engine and executes it against real market data.
Returns whether it succeeded, how many series/draw elements were produced, etc.
No auth required.

IMPORTANT PREREQUISITE:
You MUST first pass compile-time validation using TakeProfit_ValidateIndieCode before
calling this tool. Set compile_time_validated=true only if the code has already been
validated without errors.

PARAMETERS:
- code: Indie source code to run (required)
- compile_time_validated: Must be true — confirms prior compile-time validation (required)
- deep_validation: false (default) — lightweight and fast (~2-20s) check for minimal history.
                   Use during development and intermediate iterations.
                   true — deep and slower (~30-100s) check.
                   Use ONLY after the indicator code is finalized
                   and lightweight validation has passed. Required before publishing
                   to the marketplace.

WORKFLOW:
1. Ensure code passes TakeProfit_ValidateIndieCode first (compile-time validation)
2. Call this tool with compile_time_validated=true
3. On runtime_error: fix the code, re-validate with ValidateIndieCode, and retry
4. On infrastructure error: retry the call (transient backend issue)
5. For final verification: call again with deep_validation=true

RESPONSE:
JSON with per-run results and an overall summary. Each run includes: status,
series_items_count, draw_elements breakdown, non_series_cmds, timing, and any error.

Search Indie documentation using semantic search.

Official documentation: https://takeprofit.com/docs

Indie is a language for building technical analysis indicators.
Use this tool to find precise documentation about Indie syntax, semantics,
constraints, functions, algorithms, and examples.

Use when:
- you need accurate Indie details
- doc_id is not yet known
- you want to find the most relevant section before calling GetDocsChapters

PARAMETERS:
- query: natural-language or technical search query
- limit: max number of results to return
- snippet_length: snippet size in characters

RETURNS per result:
- file
- section
- type
- relevance
- snippet
- line
- total_length
- character_offset

RULES:
- Prefer this before writing Indie code
- Use file and character_offset to retrieve source context with GetDocsChapters
- Do not rely on memory when precise Indie behavior matters

Search TakeProfit platform documentation using semantic search.

Official documentation: https://takeprofit.com/docs

TakeProfit is a trading platform.
Use this tool to find precise documentation about platform features,
workflows, settings, integrations, UI behavior, and other platform topics.

Use when:
- accurate platform details are needed
- doc_id is not yet known
- you want to find the most relevant section before calling GetDocsChapters

PARAMETERS:
- query: natural-language or technical search query
- limit: max number of results to return
- snippet_length: snippet size in characters

RETURNS per result:
- file
- section
- type
- relevance
- snippet
- line
- total_length
- character_offset

RULES:
- Use file and character_offset with GetDocsChapters to read source context
- Do not rely on memory when exact platform behavior matters
- Do not use this tool for precise Indie language information; use Indie-specific
    documentation tools or the official docs instead.

Examples of platform topics include alerts, widgets, webhooks, integrations,
account settings, workspace settings, and UI navigation, but the documentation is not limited to these areas.

Search securities (tickers) by free text and return the platform's internal `ticker`
and `exchange_code` required by other TakeProfit tools.

WHEN TO USE:
- You have a human query (ticker, company name, or exchange name) and need the exact
  `ticker` and `exchange_code` used by the TakeProfit platform.
- You need to resolve or disambiguate instruments with the same ticker on different venues.

SEARCH BEHAVIOR:
- Full-text search across ticker symbol, instrument/company name, and exchange alias/name.
- Not limited to ticker-prefix lookup.
- Searching by exchange name (e.g. "NASDAQ") returns related instruments, but does NOT
  guarantee that `exchange_code` exactly matches that exchange.

PARAMETERS:
- text (str, required): Search query (e.g. "aapl", "apple", "btc", "nasdaq").
- asset_class (str, optional, default="any"): Asset class filter.
  Supported values: EQUITY, CRYPTO, TOKENIZED_STOCK, FUNDS, FOREX, FUTURE, or "any".
  Common aliases are normalized automatically (e.g. "stock" -> EQUITY, "funds" -> FUNDS,
  "futures" -> FUTURE, "*" -> any).
- offset (int, optional, default=0): Pagination offset. Applied within the first 100 matches.
- limit (int, optional, default=20): Maximum number of results to return.

RECOMMENDED WORKFLOW:
1) If the asset class is known, start with that `asset_class` (e.g. EQUITY, CRYPTO).
2) If no results are found, retry with `asset_class="any"`.
3) If multiple matches are returned, choose the exact `ticker` and required `exchange_code`.
4) Use the returned `exchange_code` as-is in other TakeProfit tools.

RESPONSE (per result):
- ticker (str): Ticker symbol.
- exchange_code (str): Platform venue code (use as-is in other tools).
- exchange_alias (str): Human-readable exchange name.
- security_class (str): Security type.
- asset_class (str): Asset class.
- full_name (str): Full instrument name.
- price (number, optional): Last available price.

Analyzes and validates Indie source code for correctness.

⚠️ IMPORTANT PREREQUISITE:
Before using this tool, you MUST confirm that you have studied the Indie language documentation
including syntax rules, constraints, built-in functions, and language-specific features.
Set 'studied_indie_documentation' to true only if you have genuinely reviewed the documentation.

This tool performs static analysis and compilation checks to identify syntax errors, version
compatibility issues, and unsupported language features. It returns a result indicating whether
the code is valid and, if not, provides an error message and suggestions.

PARAMETERS:
- code: A string containing Indie code to validate (required)
- studied_indie_documentation: Confirmation that you studied Indie docs (required, must be true)

WORKFLOW:
1. Use TakeProfit_SearchIndieDocs to find relevant Indie language features
2. Use TakeProfit_GetDocsChapters to read full documentation sections
3. Understand Indie-specific syntax, constraints, and conventions
4. Write your Indie code
5. Call this tool with studied_indie_documentation=true to validate

Use this before attempting to execute or transform Indie code to ensure correctness.