> ## Documentation Index
> Fetch the complete documentation index at: https://takeprofit.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# MCP Server Setup Guide

## What is the TakeProfit MCP Server?

LLMs can now write, convert, validate, and explain Indie code using the **TakeProfit MCP Server**.

**Get AI-Powered Indie Development Help:**

* Ask LLM to write complete indicators from scratch based on your trading ideas
* Get explanations of complex algorithm combinations and how they work together

### Discover Indicators

* Search the community **Marketplace** for published indicators by name or description — the LLM can recommend an existing indicator instead of writing one from scratch
* Search **built-in indicators** by name, title, or abbreviation

### Work with Your Own Scripts and Watchlists

The server does not stop at the language. Once you are signed in, it also reaches the private data behind your account:

* **Your private scripts** — list what is in **My scripts**, load a script into the conversation, edit it, and save it back to the platform
* **Alerts** — create, edit, pause, and review alerts, including alerts on a private indicator you never published
* **Watchlists** — list them, read what is in them with live quotes, create new ones, and add or remove instruments

See [Working with your platform data](#working-with-your-platform-data) below for what each of these can do.

**Interactive Learning:**

* Ask "how would I implement X indicator?" and get working code examples
* Understand the logic behind technical analysis through code explanations
* Learn Indie best practices through AI-guided development

**Examples:**

* "Create a momentum indicator that combines RSI and MACD divergence"
* "Help me build a support/resistance detector using price action"
* "Explain how to implement a custom volatility-based stop loss"
* "Write an indicator that detects chart patterns like triangles"

## Step-by-Step Setup Instructions

**Claude**

### Claude and Claude Desktop integration

#### Step 1: Add custom connector

1. [Download, install & sign in / sign up to Claude Desktop](https://www.anthropic.com/claude) or login using [web-interface of Claude](https://claude.ai/)

2. Go to Settings -> Connectors in [Claude](https://claude.ai/settings/connectors) or Claude Desktop and click "Add custom connector"

3. Enter the `TakeProfit` name and url `https://mcp.takeprofit.com/mcp`

   ![Add custom connector to claude](https://mintcdn.com/takeprofit-a5dc0462/ez0HV0EYm4Oh5HIq/images/indie/Mcp-server/01_Claude_Add_Connectors.png?fit=max\&auto=format\&n=ez0HV0EYm4Oh5HIq\&q=85\&s=e656663026d40cebe0186262ddafdd27)

4. Press `Configure` button for new connector, make sure all the tools are turned on and choose `Allow unsupervised` for all tools

   ![Enable tools and allow unsupervised](https://mintcdn.com/takeprofit-a5dc0462/ez0HV0EYm4Oh5HIq/images/indie/Mcp-server/02_Claude_Configure_Connectors.png?fit=max\&auto=format\&n=ez0HV0EYm4Oh5HIq\&q=85\&s=23957b10612b5f46fba3d8c539798901)

#### Step 2: Verify Functionality

1. Exit the settings and return to the chat window
2. Ask to `get the Indie docs TOC using TakeProfit MCP` or to `generate SMA indicator in Indie language and validate this using TakeProfit MCP` and watch the AI execute the technical workflow for you.

**Claude Code**

### Claude code CLI integration

*Available on macOS, Linux, and Windows.*

#### Step 1: Install NodeJS 18+ if it is not already installed

1. Go to the official Node.js website: [https://nodejs.org/en/download/](https://nodejs.org/en/download/)
2. Download the LTS (Long-Term Support) version for your operating system — it's the stable version recommended for most users
3. Run the installer — no need to change settings during installation

> You can ignore the PowerShell window that may appear and close itself after installation. If in doubt, restart your computer and continue.

#### Step 2: Install claude code

Run in the terminal: `npm install -g @anthropic-ai/claude-code`

#### Step 3: Add the integration

Execute the command `claude mcp add --transport http takeprofit https://mcp.takeprofit.com/mcp` in your terminal (not in claude chat).

#### Step 4: Authorize the connection

Run claude code with the `claude` command. If this is the first run of claude code, the setup wizard will appear and you need to complete the authorization, subscription, and configuration steps.

Then type `/mcp` in the chat, pick **takeprofit**, and choose **Authenticate** — a browser window opens for you to sign in to TakeProfit. Until that is done the server is listed as *Needs authentication* and its tools stay unavailable.

#### Step 5: Verify functionality

Ask to `get the Indie docs TOC using MCP` or to `generate SMA indicator on Indie language and validate this using MCP` and watch the tools run.

### Claude code VSCode extension integration

*Available on macOS, Linux, and Windows.*

#### Step 1: Install claude code extension to your VSCode IDE

Download and install [from marketplace](https://marketplace.visualstudio.com/items?itemName=anthropic.claude-code) or just install it in the VSCode window on the Extensions tab.

#### Step 2: Add the integration

Execute the command `/claude mcp add --transport http takeprofit https://mcp.takeprofit.com/mcp` (with leading slash) just in claude code chat. Then terminate the current chat and reopen it to apply new setting.

Reopen the chat, type `/mcp`, pick **takeprofit** and choose **Authenticate** to sign in to TakeProfit. A newly added server is only available in chats started after it was added, and its tools stay unavailable until it is authorized.

#### Step 3: Run and use

Open the chat using the `Ctrl+Shift+P` (`Cmd+Shift+P` on Mac) and `Run Claude Code` command or by clicking on the Claude code icon in the upper-right corner of the IDE window.\
Write `/mcp` to the chat to see integration info. Then ask to `get the Indie docs TOC using MCP` or to `generate SMA indicator on Indie language and validate this using MCP` to verify functionality.

**Codex**

### Codex CLI integration

#### Step 1: Install Codex

Install the Codex CLI following the [official instructions](https://developers.openai.com/codex/cli), then run `codex` once and complete the sign-in.

#### Step 2: Add the integration

Run this in your terminal (not inside the Codex chat):

```bash theme={null}
codex mcp add takeprofit --url https://mcp.takeprofit.com/mcp
```

Codex lists the servers it knows about with `codex mcp list`, so you can check that `takeprofit` was registered.

#### Step 3: Sign in to TakeProfit

Run this in your terminal as well:

```bash theme={null}
codex mcp login takeprofit
```

A browser window opens for you to sign in to TakeProfit and approve the connection. Until you do, the TakeProfit tools are not available in Codex. If Codex already opened the sign-in page when you added the server, you can skip this step.

#### Step 4: Run and use

Start Codex with the `codex` command and type `/mcp` to check that **takeprofit** is connected. Then ask it to `get the Indie docs TOC using TakeProfit MCP` or to `generate SMA indicator in Indie language and validate this using TakeProfit MCP`. Approve the tool call when Codex asks for it, and watch the AI execute the technical workflow for you.

**Cursor**

### Cursor integration

#### Step 1: Install the cursor IDE

Download cursor from [official site](https://cursor.com/downloads), run it and do the initial setup.

#### Step 2: Add the integration

1. Open Cursor Setting -> Tools & Integrations (or Cursor Setting -> MCP depends on Cursor version)
2. Press the "Add Custom MCP" button and paste this to `mcp.json` config:

```json theme={null}
{
  "mcpServers": {
    "TakeProfit": {
      "url": "https://mcp.takeprofit.com/mcp"
    }
  }
}
```

Or just add the TakeProfit server to the list if you already have other servers:

```json theme={null}
{
  "mcpServers": {
    "OtherServer1": {
      ...
    },
    "OtherServer2": {
      ...
    },
    "TakeProfit": {
      "url": "https://mcp.takeprofit.com/mcp"
    }
  }
}
```

3. Open Cursor Setting -> Models and choose a model that can work with the MCP, for example `claude-4-sonnet`

#### Step 3: Open the chat and use

Toggle AI Pane to open a chat and use new integration: ask to `get the Indie docs TOC using MCP` or to `generate SMA indicator on Indie language and validate this using MCP`. If you are not logged in to cursor yet, you will be redirected to the authorization page.

**NOTE: [cursor will wait for approve](https://docs.cursor.com/context/mcp#tool-approval) from you when using the mcp for the first time, you will need to press the "Run tool" button so that it can access the MCP**

**VSCode**

### VSCode integration

#### Step 1: Download and install the VSCode IDE

Download VSCode from [official site](https://code.visualstudio.com/Download) and install this. Make sure you're using a recent version with agent mode.

#### Step 2: Add the integration

* Auto: [click this link to install](vscode:mcp/install?\{"name":"TakeProfit","url":"https://mcp.takeprofit.com/mcp"})\
  Press "Trust" if VSCode asks "Trust and run MCP server TakeProfit?"

- Or manual:
  * press `Ctrl + Shift + P` (`Cmd + Shift + P` on Mac) to open VSCode command line and execute the `MCP: Open User Configuration` command
  * paste this to `mcp.json` config:

```json theme={null}
{
	"servers": {
		"TakeProfit": {
			"url": "https://mcp.takeprofit.com/mcp"
		}
	}
}
```

Or just add the TakeProfit server to the list if you already have other servers:

```json theme={null}
{
	"servers": {
		"OtherServer1": {
			...
		},
		"OtherServer2": {
			...
		},
		"TakeProfit": {
			"url": "https://mcp.takeprofit.com/mcp"
		}
	}
}
```

#### Step 3: Open the chat and use

* press `Ctrl + Alt + I` (`Cmd + Option + I` on Mac) to open chat or execute `Chat: Open chat` command in VSCode command line (`Ctrl + Shift + P` on Windows, `Cmd + Shift + P` on Mac)
* set up Copilot and authorize using your github account if VScode asks

- write any first message to start the chat
- select agent mode, choose a model that can work with the MCP, for example `Claude Sonnet` (enable access to the Claude model if VScode asks)

* press the Tools button to view the list of available tools and enable the TakeProfit tools

- enter a prompt to use MCP, for example `get the Indie docs TOC using TakeProfit MCP`. VSCode will wait for approve to use MCP, allow this (press `Continue` button) and watch the AI execute the technical workflow for you.

**mcp-remote**

### mcp-remote integration

Some AI applications do not support remote mcp, but can only work with local mcp tools. In this case, you can use the npm package `mcp-remote`.

For example, if you have a free claude account, integration with the remote mcp may not be available, but you can configure it with a local mcp.

#### Step 1: Install Node.js

1. Go to the official Node.js website: [https://nodejs.org/en/download/](https://nodejs.org/en/download/)
2. Download the LTS (Long-Term Support) version for your operating system — it's the stable version recommended for most users
3. Run the installer — no need to change settings during installation

> You can ignore the PowerShell window that may appear and close itself after installation. If in doubt, restart your computer and continue.

#### Step 2: Open Claude Desktop Configuration

1. If you haven't already, [download and install Claude Desktop](https://www.anthropic.com/claude)
2. Open the Claude application
3. Navigate to **File → Settings → Developer**
4. Click **"Edit Config"** — this will open the configuration file in a text editor

#### Step 3: Edit Configuration File

Open the config file, which will be located at:

* **Mac**: `~/Library/Application Support/Claude/claude_desktop_config.json`
* **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`

**If the file is empty or contains only `{}`:**\
Replace the file contents with:

```json theme={null}
{
 "mcpServers": {
  "TakeProfit": {
   "command": "npx",
   "args": [
    "-y",
    "mcp-remote@latest",
    "https://mcp.takeprofit.com/mcp"
   ]
  }
 }
}
```

**If the file already contains other MCP servers:**\
Add the TakeProfit server to the existing `mcpServers` block. For example, if the file looks like this:

```json theme={null}
{
 "mcpServers": {
  "OtherServer1": {
   "command": "..."
  },
  "OtherServer2": {
   "command": "...",
   "args": [...]
  }
 }
}
```

Then change it to:

```json theme={null}
{
 "mcpServers": {
  "OtherServer1": {
   "command": "..."
  },
  "OtherServer2": {
   "command": "...",
   "args": [...]
  },
  "TakeProfit": {
   "command": "npx",
   "args": [
    "-y",
    "mcp-remote@latest",
    "https://mcp.takeprofit.com/mcp"
   ]
  }
 }
}
```

#### Step 4: Save and Restart

1. Save the configuration file (Ctrl+S on Windows, Cmd+S on Mac)
2. Completely close Claude Desktop
3. Launch Claude Desktop again

#### Step 5: Verify Functionality

After restarting, you should see a tools icon in the bottom left corner of the chat input box. Click on it to open the "Search and tools" menu. If the TakeProfit MCP server is working correctly, you should see "TakeProfit" listed in the tools menu.

Similarly, you can use the `mcp-remote` in other situations where it is convenient.

## Test Your Setup

Try asking LLM one of these questions to test the connection:

**"Can you show me the documentation for the RSI algorithm?"**

**"Help me create a simple moving average indicator in Indie"**

**"Validate this code: \[paste some Indie code]"**

**"What algorithms are available for calculating Bollinger Bands?"**

If the MCP server is working correctly, LLM will respond using Indie documentation and logic.

Once you receive generated code, test it by pasting it into [the indicator code editor](https://takeprofit.com/docs/guide/platform/ide-widget/IDE-overview.md) on the TakeProfit platform to verify that it runs without errors.

## Ready-made Indie prompts

The server ships the same Indie know-how that the platform's own [AI Chat](https://takeprofit.com/docs/guide/platform/ai-assistant/AI-chat-page.md) uses: the language rules, the common mistakes and their fixes, and a step-by-step workflow for each kind of task. You get it in three ways.

**Prompts.** Applications that support MCP prompts list them as ready-made commands, for example in the slash-command menu of Claude or Cursor:

| Prompt | Use it to |
| - | - |
| `indie_write_indicator` | Write a new indicator from a description. |
| `indie_edit_script` | Change an existing script. |
| `indie_fix_errors` | Fix compile or runtime errors. |
| `indie_optimize` | Make a script faster or lighter. |
| `indie_migrate` | Port an indicator from Pine Script or another language to Indie. |

**The playbook tool.** `TakeProfit_GetPlaybook` returns the rules plus the steps for one task — write, edit, fix, optimize or migrate — or a single section of them. The server tells the assistant to read it before it writes or changes Indie code, so you rarely need to ask.

**Hints in tool results.** Creating or loading a script returns the playbook along with it, and a failed validation comes back with the fixes that match the error. An assistant that skips the instructions still gets the rules where it needs them.

## Working with your platform data

Everything in this section runs against your own account, so you are asked to authorize the connection to TakeProfit before any of it works. After that the assistant sees exactly what you see on the platform, and nothing more.

### Your private scripts

The server reaches the private indicators in **My scripts**, not only the code written in the current conversation. That closes the loop between the chat and the [IDE](https://takeprofit.com/docs/guide/platform/ide-widget/IDE-overview.md): pick up a script you started on the platform, work on it with the assistant, and save the result back.

* **List** returns your platform indicators and the assistant's own working copies together, newest first. Each row says whether the working copy is saved on the platform and whether a newer platform version already exists. Temporary scripts are never listed.
* **Load** brings one exact version of a private script into the conversation, where it can be read, edited, and validated. Loading never exposes built-in, published, or another user's source code.
* **Save** writes it back. The first save creates a new private indicator in **My scripts**; a later save on a script that is already linked creates its next version. A working copy with unsaved local changes is never silently overwritten.
* Once a private indicator is saved, you can put an [alert](https://takeprofit.com/docs/guide/alerts/Alerts-overview.md) on one of its plots straight away — publishing it to the Marketplace is not required.

**Prompts that work:**

```text theme={null}
List my scripts on TakeProfit.
```

```text theme={null}
Load my "ATR Bands" indicator, add an input for the multiplier, and validate it.
```

```text theme={null}
Save this as a new version of my "ATR Bands" script.
```

```text theme={null}
Create an alert on the upper band of my saved ATR Bands indicator for BTC/USDT.
```

| Tool | What it does |
| - | - |
| `TakeProfit_ListUserScripts` | Lists your private platform indicators and the assistant's working copies, with save status and version. |
| `TakeProfit_LoadPlatformScript` | Loads one version of a private platform script into the assistant. |
| `TakeProfit_SaveScript` | Saves a working copy to **My scripts**, either as a new indicator or as the next version of an existing one. |

> [!NOTE]
>
> Scripts and versions written this way land in **My scripts** on the platform like any other indicator — open the [IDE](https://takeprofit.com/docs/guide/platform/ide-widget/IDE-overview.md) to review the code, or add the indicator to a chart from there.

### Watchlists

The assistant can read and edit your [watchlists](https://takeprofit.com/docs/guide/platform/watchlist-widget/Creating-and-managing-watchlist.md), which is the fastest way to answer questions about a whole list at once instead of one ticker at a time.

* **List** returns your own watchlists with their titles and how many instruments each one holds. Built-in lists are not exposed — duplicate one into **My Watchlists** first if you want the assistant to work with it.
* **Read** returns everything stored in one list, optionally with live quotes for the whole list in a single request — the basis for "which of my names are up today" style questions.
* **Create** makes a new list, optionally pre-filled with up to 50 instruments.
* **Edit** adds and removes instruments in an existing list; both directions go in one request, so "swap AAPL for MSFT" is a single change.
* **Delete** removes a list permanently. The tool requires the exact current title as confirmation, so an assistant that mixed up two similar lists is refused instead of deleting the wrong one.

**Prompts that work:**

```text theme={null}
What is in my "Crypto majors" watchlist, and how is each name doing today?
```

```text theme={null}
Create a watchlist called "Semis" with NVDA, AMD, AVGO, and TSM.
```

```text theme={null}
Add SOL and remove DOGE from my "Crypto majors" list.
```

```text theme={null}
Set the same crossover alert on every symbol in my "Semis" watchlist.
```

| Tool | What it does |
| - | - |
| `TakeProfit_ListWatchlists` | Lists your watchlists with titles and instrument counts. |
| `TakeProfit_GetWatchlist` | Reads one watchlist, optionally with quotes for every instrument in it. |
| `TakeProfit_CreateWatchlist` | Creates a new watchlist, optionally pre-filled with instruments. |
| `TakeProfit_EditWatchlistSecurities` | Adds and removes instruments in an existing watchlist. |
| `TakeProfit_DeleteWatchlist` | Permanently deletes a watchlist. |

> [!WARNING]
>
> Deleting a watchlist cannot be undone from the chat. Confirm the list by name before you let the assistant delete it, and use the edit tool when you only want to drop a few instruments.

> [!NOTE]
>
> An instrument is stored as a ticker and an exchange together, so the assistant resolves the pair first. If a name is stored on a different venue than you asked for, it will say which one — check it before you read the quotes as your own.

### Strategy backtests

The assistant can run a [strategy](https://takeprofit.com/docs/indie/Strategies/Strategies-overview.md) through history and read the result, so you can write a strategy, test it and tune it in one conversation.

* **Strategy info** reads a strategy's parameters with their types, defaults and options before a run. It works for a script the assistant is editing and for a strategy on the platform you have access to. Indicators cannot be backtested — only strategies.
* **Run** simulates the strategy on one instrument and timeframe, over a date range or a preset history depth, with your parameter values. It returns the report metrics and the most recent orders and trades.
* **Report** reads the same run again and pages through its full order and trade history, up to 500 rows a page. It never starts a new calculation.
* **Release** frees a run you no longer need. Runs also expire on their own: each response says when, and an expired run is not recreated silently — ask for a new one.

A run belongs to you: the assistant can read only the runs it started for your account.

**Prompts that work:**

```text theme={null}
Backtest my "EMA Cross" strategy on BTC/USDT, 1 hour, for the last 6 months.
```

```text theme={null}
Run the same backtest with the fast EMA at 9 instead of 12 and compare the two.
```

```text theme={null}
Show me every losing trade from that run and what they have in common.
```

| Tool | What it does |
| - | - |
| `TakeProfit_GetStrategyInfo` | Reads a strategy's parameters, defaults and options before a backtest. |
| `TakeProfit_RunBacktest` | Runs a backtest and returns the metrics with the latest orders and trades. |
| `TakeProfit_GetBacktestReport` | Re-reads a run and pages through its orders and trades. |
| `TakeProfit_ReleaseBacktest` | Releases a run that is no longer needed. |

To look at the same strategy with charts, an equity curve and the full report, open it in the [Strategy/Backtesting widget](https://takeprofit.com/docs/guide/platform/backtesting-widget/backtest-widget.md).

### Alerts

Alert management over MCP is covered in [Alerts](https://takeprofit.com/docs/guide/alerts/Alerts-overview.md#creating-alerts-via-ai-mcp), including the full tool list.

## Notes

### Claude Account Requirements

* You'll need a Claude account to use this integration. While it technically works with any account, having a paid plan is strongly recommended so that Claude can properly handle longer prompts and return complete responses:

  * **Claude Pro (\$20/month)**: Suitable for most scripts and general usage
  * **Claude Max (\$100/month)**: Provides the largest context window, ideal for longer or complex scripts

> 💡 **Check current pricing plans here:** [https://www.anthropic.com/pricing](https://www.anthropic.com/pricing)

### Performance Notes

* Works best for code up to \~200-300 lines
* If your script is too long, try splitting it across multiple prompts or chats
* Modern LLM can usually finish or patch incomplete scripts when prompted correctly

## Common Issues and Solutions

### "node not found" Error

* Make sure Node.js is installed correctly
* Restart your computer after installation
* On Windows, check that Node.js is in your PATH environment variables

### MCP Server Won't Connect

* Check your internet connection
* Make sure the configuration file is saved correctly
* Try restarting the application
* Verify Node.js is working by running `node --version` in command line


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.