AlgoVault x LlamaIndex — Composite Trade Calls for Your LlamaIndex Agent

90.47% PFE Win Rate · 96,864+ calls · 38+ Merkle-verified on-chain batches · 738 assets covered.

Don’t trust — verify the track record → Snapshot taken 2026-05-18 — live numbers refreshed in-page from https://algovault.com/api/performance-public

AlgoVault MCP gives your LlamaIndex agent a composite verdict in one call — direction, confidence, regime, and cross-venue funding/sentiment context — backed by a publicly auditable record anchored to Base L2 (agentId 44544). Drop it into any FunctionAgent, ReActAgent, or custom workflow with llama-index-tools-mcp — the canonical MCP bridge maintained by LlamaIndex.

Provenance: llama-index-tools-mcp==0.4.8 on PyPI (verified 2026-05-18). Streamable-HTTP transport documented at https://developers.llamaindex.ai/python/framework/module_guides/mcp/llamaindex_mcp/. AlgoVault MCP endpoint: https://api.algovault.com/mcp.

What you’ll build (90s read)

A runnable Python script that:

1. Connects to AlgoVault MCP at https://api.algovault.com/mcp via BasicMCPClient (streamable HTTP transport).
2. Calls get_trade_call directly for any coin + timeframe and prints the parsed verdict.
3. (Optional) Adapts the 4 AlgoVault tools to LlamaIndex FunctionTool objects via McpToolSpec and hands them to a FunctionAgent so an LLM can decide which tool to call.

Prerequisites

1. Python >= 3.10 (python3 --version). The llama-index-tools-mcp package requires it.
2. AlgoVault skills plugin (optional helper pack for Claude Code / Cursor / Cline):

   claude plugin install AlgoVaultLabs/algovault-skills
   

3. Install the demo deps (pinned in examples/llamaindex/requirements.txt):

   pip install -r examples/llamaindex/requirements.txt
   

4. (Optional) LLM API key — only needed for the follow-on FunctionAgent snippet below. The bare python demo.py BTC 4h call works without one.

Demo: Direct trade-call read (<=80 lines)

# examples/llamaindex/demo.py (excerpt — see file for full source)
import asyncio
import json
from llama_index.tools.mcp import BasicMCPClient

ALGOVAULT_MCP_URL = "https://api.algovault.com/mcp"


async def fetch_trade_call(coin: str, timeframe: str) -> dict:
    # BasicMCPClient(url) selects streamable HTTP transport by default
    # for any http(s)://... URL that does not end in /sse.
    client = BasicMCPClient(ALGOVAULT_MCP_URL)
    result = await client.call_tool(
        "get_trade_call", {"coin": coin, "timeframe": timeframe}
    )
    payload = json.loads(result.content[0].text)
    return {k: payload[k] for k in ("call", "confidence", "indicators", "regime")}


if __name__ == "__main__":
    result = asyncio.run(fetch_trade_call("BTC", "4h"))
    print(json.dumps(result, indent=2))

Run it:

python examples/llamaindex/demo.py BTC 4h

Sample output

{
  "call": "HOLD",
  "confidence": 13,
  "indicators": {
    "funding_rate": 0.00005667,
    "funding_24h_avg": 0.00005667,
    "funding_state": "ELEVATED",
    "oi_change_pct": 0,
    "volume_24h": 8145289765.51,
    "trend_persistence": "MEDIUM",
    "breakout_pending": "INACTIVE"
  },
  "regime": "TRENDING_DOWN"
}

The 4 keys (call, confidence, indicators, regime) are the documented contract. The full MCP response also includes price, reasoning, timestamp, coin, timeframe, and _algovault provenance — all available in payload if your agent needs them.

All 4 AlgoVault tools at a glance

McpToolSpec(client=...).to_tool_list_async() returns 4 LlamaIndex FunctionTool objects:

Each tool exposes the standard LlamaIndex FunctionTool interface — call directly via await tool.acall(coin="BTC", timeframe="4h") or hand the list to any agent.

Optional: wire the tools into a FunctionAgent

If you want an LLM to decide when to call which tool, load the tools via McpToolSpec and pass them to a FunctionAgent (or ReActAgent):

import asyncio
from llama_index.tools.mcp import BasicMCPClient, McpToolSpec
from llama_index.core.agent.workflow import FunctionAgent
from llama_index.llms.anthropic import Anthropic


async def run():
    client = BasicMCPClient("https://api.algovault.com/mcp")
    spec = McpToolSpec(client=client)
    tools = await spec.to_tool_list_async()  # 4 FunctionTool objects

    agent = FunctionAgent(
        tools=tools,
        llm=Anthropic(model="claude-sonnet-4-5"),
        system_prompt="Use the AlgoVault tools to answer trading questions.",
    )
    response = await agent.run("Get a trade call for BTC on the 4h timeframe.")
    print(response)


asyncio.run(run())

Requires pip install llama-index-llms-anthropic and an ANTHROPIC_API_KEY. Swap Anthropic for any LlamaIndex LLM (OpenAI, Mistral, Ollama, Bedrock, etc.).

Why AlgoVault?

• Composite verdict, not raw indicators. One JSON response replaces 26-indicator vote-counting.
• Cross-venue signal. Funding spreads, regime, and sentiment fused across 5 venues — not derivable from any single-venue API.
• Publicly verified. Every signal anchored to Base L2 via Merkle proof. Verify before you subscribe.

90.47% PFE Win Rate · 96,864+ calls · 38+ on-chain batches → view live track record

Next steps

Run the demo at examples/llamaindex/demo.py · Pair with your LlamaIndex agent at https://api.algovault.com/mcp · Verify the track record on https://algovault.com/track-record.

Install (helper plugin)

claude plugin install AlgoVaultLabs/algovault-skills

Once installed, every Skill in the pack is one-line invokable from Claude Code, Cursor, or any MCP-compatible client.

Tutorial © AlgoVault Labs · MIT licensed · Provenance verified 2026-05-18 · llama-index-tools-mcp 0.4.8 (PyPI)