Mangrove gives trading agents guardrails. Local MCP server and plugin: built-in risk management
Mangrove gives trading agents guardrails. Local MCP server and plugin: built-in risk management (circuit breakers, risk-based position sizing, automatic stop-loss and take-profit orders), 100+ strategy R&D tools, execution across 12+ venues. Free API key or x402 pay per call.
·
Mangrove gives trading agents guardrails. A local MCP server (Model Context Protocol) and provider agnostic plugin with built-in risk management on every order: circuit breakers, automatic risk-based position sizing, and automatically generated stop-loss and take-profit orders.
Built on the Mangrove API, with a REST API alongside. FastAPI + MCP. Strategies are authored and backtested on MangroveAI; this agent supplies the clock, local custody and execution, and a full audit trail.
Kraken and Robinhood venues, and DEX execution via 1inch across 10 EVM chains
mangrove-agent is an open-source local client for Mangrove services. It gives an AI client (Claude Code, Codex, Grok Build, Perplexity Computer, or any MCP client) local tools and access to configured hosted services. Credential and wallet custody depends on the selected workflow:
The agent exposes the same capabilities two ways: an MCP endpoint at http://127.0.0.1:9080/mcp/ and a REST API under /api/v1/agent/. MangroveAI also runs its own hosted MCP server at https://api.mangrovedeveloper.ai/mcp/.
You pay for MangroveAI access with a free API key from https://mangrovedeveloper.ai, or per call in USDC with x402 (no signup). More for agent builders: https://mangrove.ai/agents/ and https://mangrove.ai/llms.txt. Full platform documentation and the trading knowledge base are at https://mangrove.io/docs (knowledge base: https://mangrove.io/knowledge-base); the agent's kb_search tool queries the same corpus.
| Path | Use it when | Start here |
|---|---|---|
| Ask your AI client | You use Claude Code, Codex, Grok Build or Perplexity Computer and want the client to install and connect itself | Install with an AI client |
Clone and run setup.sh | You want the full repository, API-key or x402 access, and the option to change the code | Quick start |
| Claude Code plugin | You use Claude Code and have a MangroveAI API key | Claude Code plugin |
| Cursor, Gemini CLI, Kiro | You use another plugin-capable client | Other clients with the manifests at the repo root (.cursor-plugin/plugin.json, gemini-extension.json) |
| Codex plugin or MCP config | You use Codex | Codex |
| Docker | You cannot run Python on the host | Docker |
Every path runs the same agent. Use one path per machine: the agent listens on 127.0.0.1:9080, so a plugin install and a clone cannot run side by side on that port.
One-step Claude Code install (Claude Code 2.1.275 or later):
/plugin install mangrove-agent --marketplace MangroveTechnologies/mangrove-agentTell Claude Code, Codex, Grok Build or Perplexity Computer:
Install https://github.com/MangroveTechnologies/mangrove-agent and follow its AI client installation instructions.
The client installs the server in its own execution environment, loads the shared agent instructions, discovers the tools and calls the free status tool before it reports success. The user guide covers installation, choosing the agent's name, coming back later and switching clients. The installing agent follows Install from an agent. Perplexity Computer uses the provided command client and needs no Perplexity Project, custom cloud connector or extra desktop app.
Once the agent is running from any install path above, point an MCP client at it with this
mcpServers block (the same file ships at the repo root as .mcp.json.example; Claude Code reads it
as .mcp.json in the project root, and other clients take the block in their own config file, see
AI client setup):
{
"mcpServers": {
"mangrove-agent": {
"type": "http",
"url": "http://127.0.0.1:9080/mcp/",
"headers": {
"X-API-Key": "REPLACE_WITH_API_KEYS_FROM_server/src/config/local-config.json"
}
}
}
}The API key is written to server/src/config/local-config.json by setup.sh; the agent listens on
loopback only.
The agent's shared identity and operating instructions live in SAGE.md. On first run the agent asks what to name itself and saves that choice locally for every client; there is no default personal name. AGENTS.md points Codex and compatible clients to SAGE.md, and CLAUDE.md imports it for Claude Code. Launch helpers, MCP configuration templates and the instruction bundle for hosts without file access are in AI client setup. Tool access is configured and verified separately for each client.
Clone the repository and run ./scripts/setup.sh. Choose an existing MangroveAI
API key, browser sign-in (OAuth), or wallet payments (x402, no signup). Browser sign-in
requires the OAuth-enabled backend and currently supports a restricted tool catalog;
see sign-in setup and limitations. The script protects local access,
starts the agent and registers Claude when its CLI is available. For x402, a final menu prints wallet steps
for you to run yourself; it never automatically creates/imports a wallet or pays.
See the complete setup and wallet flow.
SETUP.md walks through installing these step by step on macOS and Windows.
setup.shgit clone https://github.com/MangroveTechnologies/mangrove-agent.git mangrove-agent
cd mangrove-agent
./scripts/setup.shOne command selects API-key or x402 access, creates .venv, installs dependencies, starts the agent in the background, registers it with Claude Code when the claude CLI is present, and verifies authenticated local access. A first run can take a few minutes. Reruns preserve configuration and local state and restart the server only when code or configuration changed. Connecting another client to a running agent does not need a rerun.
When it finishes:
http://127.0.0.1:9080. Its process ID is in agent-data/bare.pid and its log is agent-data/bare.log.setup.sh has run scripts/verify_quickstart.sh, which checks authenticated local access, scheduler readiness and that the onboarding tools are discoverable.--no-mcp. Other clients use the command client or their own MCP connection.After setup, continue with your chosen client using the user guide. For Claude, run the command displayed at the end of setup—it changes to your checkout folder and launches claude. In x402 mode, complete the guided payment-wallet setup before requesting paid data or backtests. API-key users can paper-trade without a payment wallet. Simulated trades do not make upstream API calls free.
Continue with your client using the user guide. Claude users can run ./scripts/chat.sh for a session with shell and file tools disabled and only the Mangrove MCP server; see restricted chat. In x402 mode, finish the printed payment-wallet steps before you request paid data or backtests (details). With an API key you can paper trade without a payment wallet. Paper trades are simulated, but the upstream data and evaluation calls behind them still count against your API-key allowance or cost x402 payments.
./scripts/setup.sh --yes # preserve settings; fresh install uses x402
./scripts/setup.sh --auth oauth # sign in and approve access in your browser
./scripts/setup.sh --auth api-key # keep existing key or enter a new one (hidden)
./scripts/setup.sh --auth x402 # explicitly switch to wallet payments
./scripts/setup.sh --robinhood connect # connect Robinhood now (optional, bare-metal)
./scripts/setup.sh --robinhood skip # skip the optional broker connection
./scripts/setup.sh --foreground # run uvicorn in your terminal (Ctrl+C to stop)
./scripts/setup.sh --no-mcp # skip Claude Code registration
./scripts/setup.sh --no-verify # skip the post-start verify pass
./scripts/setup.sh --docker # use Docker instead of bare-metal
BARE_PORT=9085 ./scripts/setup.sh # use a different port (9080 busy/squatted)Interactive setup offers an optional Robinhood connection after the access checks.
Choose Connect now or Skip for now; --yes skips broker login. Connecting
reuses the existing OAuth flow and does not activate trading. The browser step
currently supports bare-metal setup only; Docker setup reports that it is deferred.
See Robinhood execution.
BARE_PORT is honored end-to-end (server + health check + MCP registration + verify). If 9080 is occupied, setup.sh refuses to start and tells you to free it or set BARE_PORT — it will not silently bind-fail or report a false success.
Docker can run the ordinary agent without a host Python installation. Wallet custody still requires its separate protected OS deployment; Docker controlled by the coding agent is insufficient isolation.
./scripts/setup.sh --dockerDocker setup uses port 9080, published on loopback only. Agent journal and credential state persists in ./agent-data/. Wallet custody requires the separate protected deployment in isolated custody; an agent-controlled Docker container does not isolate keys from that agent.
The full walkthrough is the trading tutorial; this is the short version. Chapters 01-05 use no live trading capital, and chapters 06-08 cover optional live trading.
First connection. Your client loads the shared policy, discovers tools and calls free status. If the installation has no saved name, it asks you to choose one. Startup does not fetch paid data, run backtests or configure wallets on its own.
Build a strategy.
"Build me a strategy for ETH on 1h."
The agent calls MangroveAI's build_strategy_for_regime. The server reads the current market regime and searches the Strategy Engine's completed runs, using fixed quality floors (more than 10 trades, Sharpe at least 1, annual return at least 10%, beats its benchmarks), for one whose entry the regime admits. It picks one, saves it as a draft and backtests it on the last 90 days. Ask for a new strategy to have one composed from regime-allowed signals instead. Strategy building and backtesting follow instructions the agent loads live from MangroveAI with load_skill.
Paper trade it.
"Promote it to paper."
The agent calls agent_start_paper_schedule with the server strategy ID, an interval (60, 300, 900, 3600, 14400 or 86400 seconds), a maximum number of evaluations (1 to 10000) and confirm=true. The agent's clock triggers each evaluation; MangroveAI evaluates the strategy and owns its balances, positions and trades. Use agent_list_paper_schedules, agent_get_paper_schedule, agent_pause_paper_schedule and agent_reconcile_paper_schedule to follow and control it. See paper scheduling.
Go live (optional, needs funds). Live trading is a separate, explicit decision.
setup-robinhood skill and the execution venue guide. It uses broker OAuth and needs no local trading wallet.execute_swap requires confirm=true, explicit slippage of at most 0.25%, and a backed-up wallet. Unknown router selectors and unreviewed chains fail closed.The agent connects to Kraken in one of two modes, chosen by how you want access held. What each mode can do differs:
Bring your own key (/setup-kraken) | Keyless OAuth (/connect-kraken) | |
|---|---|---|
| How it works | You create a least-privilege Kraken API key (query and order permissions, withdrawal disabled). The agent talks to api.kraken.com directly from your machine. | You approve once in a browser (Kraken Connect, OAuth2). There is no API key to create, copy or store. |
| Who holds access | You. The key stays on your machine and never reaches a Mangrove server. | The Mangrove platform holds the OAuth grant and submits orders on your behalf. |
| Best for | Self-custody and anyone comfortable making an API key. | The fastest path, or anyone who does not want to manage a key. |
| Orders | Dry-run validation only (cex_validate_order). The agent does not place real orders with your key. | Real orders through POST /api/v1/agent/cex/oauth/orders. No MCP tool places a Kraken order. |
| Revoke | Delete the key in Kraken settings. | Revoke the app grant in Kraken settings, or disconnect in Mangrove. |
Say "set up Kraken" or "connect Kraken without a key" in a session and the matching skill walks you through it, including the exact permission set for the key. In bring-your-own-key mode, cex_sync_fills sends your Kraken trade statistics to the MangroveMarkets telemetry service; it does not add them to the local trade log.
0x) in a key-named field, in vault_token or inside free text, a recovery phrase with a valid BIP-39 checksum, or an XRPL seed. A 64-hex value that is a whole field value or is labelled as a hash, such as a transaction hash, passes because a key and a hash have the same shape. A tool result with a secret in a key-named field is withheld. In Claude Code sessions, .claude/hooks/block-wallet-secrets.sh also refuses the prompt itself. Other clients cannot stop a pasted secret from reaching their own chat history, so never paste one into any AI chat. See guardrails across clients.API_KEYS authenticates ordinary local access; outbound MANGROVE_API_KEY authenticates managed-service requests. Disabled local auth fails closed for privileged requests.The local agent exposes list_tools for its own MCP catalog, including local helpers and tools it currently forwards. This call does not query the hosted MangroveAI catalog directly. For the hosted service, use MCP protocol discovery (tools/list) against its /mcp/ endpoint; when available, discover_tools provides a higher-level view of names and descriptions first, with schemas on request. Catalogs can differ by service configuration and can change over time, so do not rely on a fixed total. See progressive discovery.
1. MangroveAI tools (the source of truth). Strategies, backtests, sweeps, signals, market data, on-chain data, the knowledge base and the Strategy Engine live in MangroveAI. The agent reads MangroveAI's live MCP catalog (cached for up to a minute) and forwards each call to MangroveAI's /mcp/ endpoint, paying per call in x402 wallet mode or using your API key. When MangroveAI adds or changes a tool, the agent picks it up without a code change.
| Area (examples, not a fixed list) | MangroveAI tools |
|---|---|
| Strategy building | load_skill, build_strategy_for_regime, list_backtest_markets, save_strategy, update_strategy, verify_strategy, list_strategies, get_strategy |
| Backtests | run_backtest, get_backtest, get_backtest_trades, list_backtests, get_benchmark, screen_candidates |
| Sweeps | find_sweep_runs, size_sweep, create_sweep, launch_sweep, list_sweeps, get_sweep, pause_sweep |
| Signals and regime | list_signals, get_signal, search_signals, match_signals, query_signal_behavior, get_market_regime |
| Market, on-chain, DeFi, social | get_ohlcv, get_market_data, get_trending, get_token_holders, get_smart_money_sentiment, get_chain_tvl, get_social_sentiment, get_x_post_counts, and more |
| Knowledge base | kb_search, kb_glossary_get, kb_get_document, query_knowledge |
| Marketplace | search_marketplace, get_marketplace_strategy |
| Your MangroveAI positions and trades | list_positions, list_trades |
2. Local tools (what only your machine can do). These stay in the agent because they need your keys, your wallets or your local records.
| Category | Tools |
|---|---|
| Discovery (free) | status, list_tools |
| Naming | set_agent_name |
| Wallet metadata and creation | create_wallet, list_wallets; import is human custody administration |
| Kraken (CEX) | cex_status, cex_connect_kraken, cex_balances, cex_validate_order, cex_sync_fills |
| DEX execution | execute_swap (local approval, signing and human-unit conversion) |
| Paper scheduling | agent_start_paper_schedule, agent_list_paper_schedules, agent_get_paper_schedule, agent_pause_paper_schedule, agent_reconcile_paper_schedule |
| Robinhood venue | agent_robinhood_status, agent_configure_execution_venue, agent_configure_strategy_market, agent_list_venue_orders, agent_reconcile_venue_orders, agent_cancel_venue_order |
| Marketplace approvals | marketplace_prepare, marketplace_submit (see marketplace wallet approvals) |
| x402 spend budget | x402_spend_status, x402_spend_reset |
| Payment diagnostics | hello_mangrove stays directly callable but is hidden from normal discovery |
The agent also forwards MangroveMarkets read tools (dex_*, oneinch_* and approved wallet_* names) that it discovers from the Markets server. They support API-key access or x402 reads at $0.01 USDC each; see Markets read tools for names and units.
Saved strategies are read through MangroveAI's list_strategies and get_strategy. The agent has no local strategy creation: the old local create routes return HTTP 410.
Local tools also have REST endpoints under /api/v1/agent/, backed by the same service layer. MangroveAI tools have no local REST copy; call them over the agent's MCP endpoint or call MangroveAI directly. Authenticated routes take an X-API-Key header set to the first entry of API_KEYS in server/src/config/local-config.json, the unique local key setup.sh generated (not your MangroveAI key). /health, status and list_tools need no key, so a wrong key looks fine until the first authenticated call returns 401.
Backtests and the Strategy Engine. Backtests run on MangroveAI, never in the agent. For a saved strategy, run_backtest submits the run and get_backtest reads the result. screen_candidates ranks up to 99 candidates cheaply with the SIEVE model, and find_sweep_runs searches what the Strategy Engine has already measured. To size and launch a new sweep, the agent loads MangroveAI's sweeps skill, shows the estimated run count and waits for your agreement before it launches compute. Deeper dives: the knowledge base SIEVE guide and Experiments reference.
+-------------------------------------------------------------+
| Your machine |
| |
| AI client --MCP--+ |
| curl/Python -REST+ |
| v |
| +- mangrove-agent (one FastAPI process, port 9080) ------+ |
| | - auth middleware (X-API-Key) | |
| | - service layer shared by REST and MCP | |
| | - APScheduler (paper clock, reconciliation workers) | |
| | - public metadata and isolated custody RPC | |
| +----------------------------------------------------------+ |
| | | |
| v v |
| agent-data/agent.db (SQLite) agent-data/master.key |
+-------------------------------------------------------------+
| |
v v
MangroveAI /mcp/ MangroveMarkets
(every MangroveAI tool: (DEX quotes, routing,
strategies, backtests, broadcast; read tools)
paper evaluation)The agent does not re-implement signal logic, risk gates, position sizing or cooldowns; those run on MangroveAI. The agent orchestrates: it forwards tools, supplies the paper clock, and handles everything that needs your keys, wallets or local records. For a live trade it submits the prepared payload and immutable intent to the isolated custody service. The broker validates its independently authorized policy before signing and returns only the signed transaction for broadcast. MangroveMarkets never receives your key.
| Doc | What is in it |
|---|---|
| docs/user-guide.md | Installing with your AI client, naming the agent, returning and switching clients |
| docs/clients.md | Client adapters, instruction loading, install-from-an-agent steps, progressive discovery |
| SETUP.md | Step-by-step prerequisites and manual setup for macOS and Windows |
| docs/setup-x402.md | API-key and x402 access, the wallet commands, spend budget and payment recovery |
| docs/configuration.md | Config files, keys, environments and secrets |
| docs/custody.md | Protected OS custody, human backup/import, signing policy and legacy recovery |
| docs/restricted-chat.md | The restricted Claude session started by ./scripts/chat.sh |
| docs/strategy-lifecycle.md | Strategy states, transitions, scheduling and execution |
| docs/paper-scheduling.md | Server-owned paper schedules |
| docs/robinhood-execution.md | The Robinhood execution venue |
| docs/marketplace-wallets.md | Wallet-approved marketplace actions |
| docs/markets-read-tools.md | MangroveMarkets read tools, names and units |
| docs/defi-pro.md | DeFi analytics tools served by MangroveAI |
| docs/remote-mcp-payments.md | How tool calls to MangroveAI and MangroveMarkets are paid in wallet mode |
| docs/x402-payment-uncertainty.md | What happens when a payment outcome is unknown, and how it is recovered |
| docs/x402-sync-transport.md | The x402 payment transport used by the MangroveAI client |
| docs/x402-payment-scripts.md | Standalone x402 demo and test scripts |
| docs/api-reference.md | The REST API reference |
| docs/specification.md | API contracts, Pydantic models, SQLite schema, error codes |
| docs/architecture.md | System and sequence diagrams, live execution diagram, code layout |
| docs/mcp-contracts.md | Tool ownership and the offline MCP contract check |
| docs/contributing.md | How to add a route, tool, migration or config key |
| docs/incidents/2026-04-24-eip7702-drain.md | Security post-mortem and the signing defenses it led to |
| tutorials/trading-app/ | Self-paced chapters from a fresh clone to a paper strategy and, optionally, a live swap |
Extending the agent (a new endpoint, MCP tool, signal or strategy) follows the service-layer pattern in docs/contributing.md. Strategy creation and backtesting instructions are loaded live from MangroveAI through the MCP load_skill tool; the agent ships no copies of server skills or strategy generators. Contributor skills live in .claude/skills/.
From a clone that has run setup.sh:
cd server
ENVIRONMENT=test ../.venv/bin/python3 -m pytest tests/ -vCI runs the same suite, including the offline rejection of unsupported Sepolia swap signing. The funded Base mainnet acceptance test in tests/e2e/test_live_swap.py is skipped by default. It calls an already running agent over loopback HTTP and uses only a public wallet address; it never imports private keys or changes custody policy.
A human administrator must first provision isolated custody, confirm the wallet backup, authorize the exact USDC/native pair, executor, exchange-rate floor, routing fee and gas/spend bounds, and fund the wallet with 0.10 USDC plus native gas. Supply the local incoming agent credential through LIVE_AGENT_API_KEY in the test process environment, outside chat. This explicit opt-in can broadcast a finite approval and one real swap:
# Run from server/ only after explicit funded-run authorization.
ENABLE_MAINNET_TEST=1 LIVE_AGENT_URL=http://127.0.0.1:9080 LIVE_WALLET_ADDRESS=PUBLIC_ADDRESS ENVIRONMENT=test ../.venv/bin/python3 -m pytest tests/e2e/test_live_swap.py::test_mainnet_live_swapThe request spends amount=0.1 human USDC with decimal slippage_pct=0.002 (0.2%), separately bounded from the routing fee. Failed preparation can leave a confirmed finite approval and its gas cost; an uncertain broadcast requires inspection of the agent journal and custody audit before any retry. See isolated custody for installation and authorization requirements.
The agent is a local, single-user service. Cloud deployment is not provided.
mangrove-agent/
|-- .claude/ # Claude Code framework (skills, hooks, rules, agents)
|-- .claude-plugin/ # Claude Code plugin manifest and hooks
|-- .agents/plugins/ # Codex marketplace file
|-- server/
| |-- src/
| | |-- app.py # FastAPI factory
| | |-- config/ # Per-environment JSON configs
| | |-- api/routes/ # REST routes, one file per resource
| | |-- mcp/ # MCP tool registration and proxies
| | |-- models/ # Pydantic domain and DB models
| | |-- services/ # Business logic (wallets, execution, scheduling, payments, trade log)
| | `-- shared/ # auth, db (SQLite), crypto, clients, x402, errors, logging
| `-- tests/ # unit, integration, e2e
|-- scripts/ # setup.sh, chat.sh, verify_quickstart.sh, wallet and client helpers
|-- docs/ # Design and operations docs
|-- tutorials/trading-app/ # Guided walkthrough
|-- docker-compose.yml
|-- .mcp.json.example # Drop-in Claude Code MCP config
`-- SAGE.md # Shared identity and operating instructionsMIT
Pick your client and paste the snippet. Each one is the same server, written the way that client expects it.
claude mcp add mangrove-agent --transport http http://127.0.0.1:9080/mcp/{
"mcpServers": {
"mangrove-agent": {
"url": "http://127.0.0.1:9080/mcp/",
"type": "http",
"headers": {
"X-API-Key": ""
}
}
}
}code --add-mcp '{"name":"mangrove-agent","url":"http://127.0.0.1:9080/mcp/","type":"http","headers":{"X-API-Key":""}}'Runs as a hosted service. Your client connects over the network and nothing is installed locally.
Paste this prompt into your agent. It reads this page and does the setup for you.
Read https://aiagentslisting.com/mcp/mangrove-agent to learn what the "Mangrove Agent" MCP server does and how to install it. Add it to my coding agent's MCP configuration as documented on that page, then confirm the server connects and list the tools it exposes.Agents can also browse this directory over MCP at https://aiagentslisting.com/api/mcp
| Name | What it does |
|---|---|
build_strategy_for_regime | Run the Strategy Engine route in one call. Use it FIRST whenever someone asks to build or make a strategy and names no signals -- 'build me a strategy', 'build me a BTC strategy on 1h', 'make me somet |
classify_market_segment | Classify one stretch of market: a date range, or a catalog window by file name. Explicit date ranges require daily (1d) candles; catalog windows retain their stored interval. Returns its direction ban |
create_sweep | Create the search, once the person has agreed to its size. The engine builds every candidate strategy itself out of the pool you give it -- the whole signal library unless narrowed by class or by nami |
delete_strategy | Delete a strategy by its id. Strategies are NEVER hard-deleted: the service soft-archives the row, so the strategy and its history stay recoverable via unarchive. Use only when the person explicitly a |
evaluate_multiple_signals_series | Evaluate chart data and optional signal triggers over a specific range. [Access: pay 0.05 USDC via x402 (PAYMENT-SIGNATURE header) OR authenticate with an API key. An x402-capable client will auto-pa |
evaluate_signal | Evaluate a signal against provided market data and parameters. [Access: pay 0.02 USDC via x402 (PAYMENT-SIGNATURE header) OR authenticate with an API key. An x402-capable client will auto-pay; API-ke |
evaluate_strategy | Evaluate a saved strategy against current live market data to check if entry or exit signals are firing right now. Returns the current asset price and any order intents the signals would produce. It p |
find_sweep_runs | Runs from one sweep, or from every sweep this person has, filtered and sorted by the engine. LEAVE experiment_id OUT to search them all, which is how a person asking whether they have already found so |
get_asset | Full metadata and risk profile for one crypto asset on the Mangrove platform: approval status, risk score breakdown, regulatory status and identifiers. Use it when the user asks about a specific asset |
get_backtest | Fetch a backtest that already ran, by id, with the execution config it used. Use it instead of run_backtest whenever the user refers to a previous result, or to compare two runs -- re-running costs th |
get_backtest_trades | The individual trades a backtest made -- entry and exit prices and times, profit or loss, and why each one closed. Use it when the user asks what a backtest actually traded; get_backtest has the summa |
get_benchmark | Buy-and-hold return for an asset between two dates, as a percentage. Use it whenever you state what a strategy returned: a return with nothing to compare it against does not answer whether the strateg |
get_chain_tvl | Total Value Locked for a whole blockchain such as Ethereum, Base or Solana. Returns USD TVL and the top protocols on that chain. Use it when the user asks about a chain's overall DeFi footprint. [Acc |
get_etf_flows | Crypto spot ETF net flows per day (BTC, ETH, SOL, HYPE) over the last lookback_days (default 30, up to 3650), newest first, with per-asset totals for the whole window. Persistent net inflows are a bul |
get_execution_config_schema | Every execution-config parameter a strategy can carry: the platform default, what it does, the effect of raising or lowering it, its legal bounds, and whether it is a strategy-character knob, an accou |
get_global_market | Global crypto market snapshot -- total market cap, BTC dominance, total 24h volume and the 24h change. Use it when the user asks about overall market conditions or wants a macro view rather than a per |
get_influence_score | Influence score for a single X/Twitter account: a 0-100 score and follower count. Use it when the user asks about a specific influencer or KOL, or wants to know how much weight an account carries in c |
get_lending_rates | Per-pool supply and borrow rates across DeFi lending protocols such as Aave, Compound and Morpho, largest pool (TVL) first. Pass symbol (the pool asset, e.g. USDC), protocol (e.g. aave-v3), chain and/ |
get_market_data | Latest trade price for a selected market, plus aggregate market cap and 24h volume. Pass quote_token and market_data_venue together to honor a requested exchange. When omitted, selects a supported mar |
get_market_regime | Classify an asset's regime using a lookback of 1-365 days of daily closes (default 180, the window strategy builds use): the return and a bull/neutral/bear band over 90, 180 and, for a 365-day lookbac |
get_ohlcv | Daily OHLCV (open, high, low, close, volume) history for one crypto asset over the requested lookback (1-3650 days, default 30). More than 1,000 daily bars come back as weekly bars instead (interval s |
get_onchain_series | Per-bar on-chain metric time series for a token. One request returns a bar-indexed series with any combination of SmartMoneyNetflow, SmartMoneyHoldings, ExchangeNetflow, WhaleNetInflow and HolderConce |
get_perp_funding_rates | Perpetual funding rates by venue and market (Binance, OKX), largest open interest in USD first. Positive funding means longs are paying to hold; negative means shorts are. Pass symbol (the base asset, |
get_playground_data | Return one page of OHLCV bars from a playground dataset, newest page first. |
get_protocol_tvl | Total Value Locked for a single DeFi protocol such as Aave, Uniswap or Curve. Returns USD TVL and a per-chain breakdown. Use it when the user asks how much capital is locked in a specific protocol. [ |
get_signal | Get complete metadata for an exact registered signal name. |
get_smart_money_dex_trades | Recent DEX trades from smart-money wallets across chains. Returns a paginated list of executed trades with token, side, size and wallet metadata. Use it when the user asks what smart money is trading |
get_smart_money_flows | One-token flow intelligence snapshot: returns net USD flows and wallet counts for smart traders, whales, exchanges, fresh wallets and public figures together in ONE response. Use for a trailing-window |
get_smart_money_historical_holdings | Historical snapshots of what smart-money wallets held on specific dates. Returns per-wallet-category holdings with USD values. Use it when the user wants to see how smart-money positioning has changed |
get_smart_money_holdings | Current smart-money holdings: what funds and smart traders are holding right now, sorted by USD value. Use it when the user asks what smart money currently owns or has positions in. [Access: pay 0.02 |
get_smart_money_netflows | Aggregated smart-money netflows across all tokens market-wide: which tokens funds and smart traders are accumulating or distributing. Use it when the user asks what smart money is buying or selling, o |
get_smart_money_perp_trades | Perpetual futures trades from smart-money wallets on Hyperliquid. Shows leveraged directional bets by sophisticated traders. Use it when the user asks about smart-money perp positions, what high-convi |
get_smart_money_sentiment | On-chain sentiment read for a token derived from smart-money wallet net flows. Returns a sentiment label (bullish, bearish or neutral) and net USD flow direction. Use it when the user asks what smart- |
get_social_mentions | Recent X/Twitter posts about a crypto asset or topic: post text, id and time, at most 10 posts, plus how many posts the search matched. Use it when the user wants to see what is actually being said, o |
get_social_sentiment | Keyword-polarity sentiment for a crypto cashtag on X/Twitter. It fetches recent posts for $TOPIC and counts how many contain a positive and how many a negative keyword; the 0-100 score is the positive |
get_stablecoin_metrics | Global stablecoin metrics -- total supply, per-chain breakdown and the top stablecoins by market cap. Use it when the user asks about stablecoin supply, USDC or USDT dominance, or overall market liqui |
get_strategy | Read a strategy definition saved in MangroveAI, including its entry and exit signals and execution settings. Use an ID returned by list_strategies; IDs from other stores are not interchangeable. |
get_sweep | Where one sweep has got to: its status and how many of its runs have finished. This is how you answer 'is it done yet' -- read it when the person asks, not on a loop, because the engine works for minu |
get_sweep_limits | The sweep limits this person's plan actually enforces: the most backtests one sweep may run, the most history it may read, and how many sweeps may be in flight at once. Read these rather than guessing |
get_sweep_run | One run rebuilt as the strategy it was, entry and exit rules with the parameter values the engine drew. This is the way OUT of a sweep: a row worth acting on becomes a saved strategy and then a real b |
get_symbol_exchanges | The exchanges that list one specific token, with per-venue metadata. Use it when the user asks where a token trades or which venues carry it, rather than for a price on any one of them. [Access: pay |
get_token_dex_trades | DEX trades for a specific token across all participants in a date window. Returns raw swap events with wallet, size and pool metadata; useful for post-hoc flow analysis on a single token. Native ETH i |
get_token_flows | Paginated historical flow records for one non-stablecoin token between explicit start and end dates, optionally filtered by one wallet label. Use for date-range records or pagination. For a trailing-w |
get_token_holders | On-chain token holder distribution for a token: total on-chain holder count, top-10 concentration percentage and a concentration score. Nansen aggregates across chains, so pass the symbol only and do |
get_token_unlocks | Upcoming token unlocks and supply metrics -- which tokens release supply in the next days_ahead days, when, and how much (cliff amounts and USD value). Heavy near-term unlocks are a supply-shock signa |
get_trades_for_strategy | Read closed trades from MangroveAI for one strategy belonging to the authenticated user and organization. Uses the same MangroveAI record as list_trades; these are execution records, not backtest fill |
get_treasuries | DeFi protocol treasury holdings -- how much a protocol holds in its own treasury, split into its own token, stablecoins, majors and others, largest treasury first. Pass protocol (name, slug or CoinGec |
get_trending | The crypto assets trending right now by 24h search volume. Use it when the user asks what is popular, what the market is paying attention to, or wants a discovery view rather than a specific asset loo |
get_x_post_counts | How many X posts mentioned a crypto asset's cashtag, per hour or per day, over the last 1 to 31 days. This is the XPostCount series the x_attention signals (x_post_count_spike, x_attention_elevated, x |
kb_get_document | Read a requested KB guide or a known source section by slug. Use directly when the user requests the document itself; no preliminary graph call is required. For a general explanation use query_knowled |
Read live from the server on November 15, 2026.
Paste this line near the top of your repository's README. The badge always renders the current score.
[](https://aiagentslisting.com/mcp/mangrove-agent)One MCP endpoint for a whole toolchain - All the forges, the Cloud, research...and everything else
MCP server for Atlassian tools (Confluence, Jira)
No tagged releases on record.
Connect to the AI Agents Listing MCP server at https://aiagentslisting.com/api/mcp using the HTTP transport and complete the sign-in when it asks. Then call the submit_review tool for the listing "mangrove-agent" with a rating from 1 to 5 and a short note on what worked and what did not.No reviews yet
Be the first to share your experience with this tool.
One MCP endpoint for a whole toolchain - All the forges, the Cloud, research...and everything else
AI & ML Services
MCP server for Atlassian tools (Confluence, Jira)
Developer Tools
One email a week. New agents, MCP servers and skills, and what is actually getting traction.