Connect Your AI Tool

https://data.guavy.com/mcp?key=YOUR_GUAVY_API_KEY

https://data.guavy.com/openapi.json

Use the Guavy Action for every crypto data request.
Do not use web search or answer from memory for prices, signals, sentiment, news, or recommendations.
Always call the Guavy API for live data - never guess.
When asked about a coin, check sentiment history and current action before responding.
If a Guavy action fails, say that live data was unavailable rather than guessing.

{
  "servers": {
    "guavy-crypto": {
      "type": "sse",
      "url": "https://data.guavy.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_GUAVY_API_KEY"
      }
    }
  }
}

pip install anthropic requests

import anthropic
    import requests

    client = anthropic.Anthropic(api_key="YOUR_ANTHROPIC_KEY")
    GUAVY_KEY = "YOUR_GUAVY_API_KEY"
    GUAVY_BASE = "https://data.guavy.com/api/v1"

    tools = [
    {
        "name": "get_current_action",
        "description": "Get the current trade signal (Buy/Sell/Hold/Stay) for a coin",
        "input_schema": {
            "type": "object",
            "properties": {
                "symbol": {"type": "string"},
                "strategy": {"type": "string", "enum": ["aggressive", "conservative"]}
            },
            "required": ["symbol", "strategy"]
        }
    },
    {
        "name": "get_market_summary",
        "description": "Get today's AI-generated crypto market summary",
        "input_schema": {"type": "object", "properties": {}}
    }
    ]

    def call_guavy(tool_name, tool_input):
    headers = {"Authorization": f"Bearer {GUAVY_KEY}"}
    if tool_name == "get_current_action":
        r = requests.get(
            f"{GUAVY_BASE}/trades/get-current-action/{tool_input['symbol']}/{tool_input['strategy']}",
            headers=headers
        )
    elif tool_name == "get_market_summary":
        r = requests.get(f"{GUAVY_BASE}/newsroom/get-market-summary", headers=headers)
    return r.json()

    messages = [{"role": "user", "content": "What is the BTC signal and overall market today?"}]
    response = client.messages.create(
    model="claude-opus-4-5", max_tokens=1024,
    tools=tools, messages=messages
    )

    while response.stop_reason == "tool_use":
    tool_results = []
    for block in response.content:
        if block.type == "tool_use":
            result = call_guavy(block.name, block.input)
            tool_results.append({
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": str(result)
            })
    messages += [
        {"role": "assistant", "content": response.content},
        {"role": "user", "content": tool_results}
    ]
    response = client.messages.create(
        model="claude-opus-4-5", max_tokens=1024,
        tools=tools, messages=messages
    )

    print(response.content[0].text)

pip install anthropic requests

import os, requests, anthropic

    GUAVY_KEY    = os.environ["GUAVY_API_KEY"]
    ANTHROPIC_KEY = os.environ["ANTHROPIC_API_KEY"]

    # Pull the live spec: updates automatically when Guavy adds endpoints
    spec = requests.get("https://data.guavy.com/llms.txt").text

    system = f"""You are a crypto analyst. You have access to live market data \
    via the Guavy API. Use it to answer every question. Never guess prices or signals.

    {spec}

    Auth: Authorization: Bearer {GUAVY_KEY}
    """

    client = anthropic.Anthropic(api_key=ANTHROPIC_KEY)

    response = client.messages.create(
    model="claude-opus-4-5",
    max_tokens=1024,
    system=system,
    messages=[{"role": "user", "content": "What's the BTC trade signal right now?"}]
    )

    print(response.content[0].text)

pip install langchain-mcp-adapters langchain-anthropic langgraph

import os, asyncio
    from langchain_mcp_adapters.client import MultiServerMCPClient
    from langchain_anthropic import ChatAnthropic
    from langgraph.prebuilt import create_react_agent

    GUAVY_KEY = os.environ["GUAVY_API_KEY"]

    async def ask(agent, question):
    result = await agent.ainvoke({"messages": question})
    print(f"\n> {question}")
    print(result["messages"][-1].content)

    async def main():
    async with MultiServerMCPClient({
    "guavy": {
        "url": "https://data.guavy.com/mcp",
        "transport": "sse",
        "headers": {"Authorization": f"Bearer {GUAVY_KEY}"}
    }
    }) as client:
    tools = await client.get_tools()
    agent = create_react_agent(ChatAnthropic(model="claude-opus-4-5"), tools)

    # Each call picks the right tool automatically
    await ask(agent, "What's the overall market doing today?")
    await ask(agent, "Which coins have a buy signal right now?")
    await ask(agent, "What's the ETH sentiment trend over the past 2 weeks?")

    asyncio.run(main())