> TickerLayer documentation for AI agents and LLMs, the Markdown version of https://tickerlayer.com/docs/agent-frameworks
> REST base URL https://api.tickerlayer.com, API key in the `x-api-key` header. WebSocket wss://stream.tickerlayer.com?apiKey=YOUR_API_KEY.
> Any docs page reads as Markdown at its URL plus `.md`. Index: https://tickerlayer.com/llms.txt · Full API reference: https://tickerlayer.com/llms-full.txt

# Agent Frameworks

Give agents built with LangChain, the OpenAI Agents SDK, the Vercel AI SDK, CrewAI, LlamaIndex, Google ADK, Pydantic AI, Mastra, smolagents or Agno live and historical market data. Each framework's own MCP client connects to the TickerLayer MCP server with your API key, so there is no extra package to install.

## How it works

Every framework below ships an MCP client. Point it at the hosted [TickerLayer MCP server](https://tickerlayer.com/docs/mcp) with your key in a header and the agent gets the same tools as Claude or Cursor: quotes, snapshots, history, symbol search, market hours and bond yields across every asset class.

- **Endpoint:** `https://mcp.tickerlayer.com/mcp` (Streamable HTTP)
- **API key:** Sent as the `x-api-key` header. The examples read it from the `TICKERLAYER_API_KEY` environment variable; [create a free account](https://tickerlayer.com/signup) to get one.
- **Tools:** The full set listed under [available tools](https://tickerlayer.com/docs/mcp#tools); every one only reads data.
- **Limits:** Plan entitlements and [rate limits](https://tickerlayer.com/docs/limits) apply exactly as for REST.
- **Model:** The examples use a Claude model; any model the framework supports works the same way.

## LangChain

LangChain's MCP adapters turn every TickerLayer tool into a LangChain tool, in Python and in JavaScript. In Python, the langchain-tickerlayer package gives an agent the same tools without MCP.

```python
# pip install langchain langchain-mcp-adapters langchain-anthropic
import asyncio
import os

from langchain.agents import create_agent
from langchain_mcp_adapters.client import MultiServerMCPClient

client = MultiServerMCPClient({
    "tickerlayer": {
        "transport": "streamable_http",
        "url": "https://mcp.tickerlayer.com/mcp",
        "headers": {"x-api-key": os.environ["TICKERLAYER_API_KEY"]},
    }
})


async def main():
    tools = await client.get_tools()
    agent = create_agent("anthropic:claude-sonnet-5-5", tools)
    question = {"role": "user", "content": "How is BTCUSD doing today?"}
    result = await agent.ainvoke({"messages": [question]})
    print(result["messages"][-1].content)


asyncio.run(main())
```

```javascript
// npm i langchain @langchain/mcp-adapters @langchain/anthropic
import { MultiServerMCPClient } from "@langchain/mcp-adapters";
import { createAgent } from "langchain";

const client = new MultiServerMCPClient({
  tickerlayer: {
    transport: "http",
    url: "https://mcp.tickerlayer.com/mcp",
    headers: { "x-api-key": process.env.TICKERLAYER_API_KEY! },
  },
});

const tools = await client.getTools();
const agent = createAgent({ model: "anthropic:claude-sonnet-5-5", tools });
const result = await agent.invoke({
  messages: [{ role: "user", content: "How is BTCUSD doing today?" }],
});
console.log(result.messages.at(-1)?.content);
await client.close();
```

**Python package**

```python
# pip install langchain-tickerlayer langchain langchain-anthropic
from langchain.agents import create_agent
from langchain_tickerlayer import TickerLayerToolkit

# Reads TICKERLAYER_API_KEY from the environment.
tools = TickerLayerToolkit().get_tools()
agent = create_agent("anthropic:claude-sonnet-5-5", tools)

question = {"role": "user", "content": "How is BTCUSD doing today?"}
result = agent.invoke({"messages": [question]})
print(result["messages"][-1].content)
```

## OpenAI Agents SDK

Give the agent the server as an MCP server: the SDK lists the tools and calls them during the run.

```python
# pip install openai-agents
import asyncio
import os

from agents import Agent, Runner
from agents.mcp import MCPServerStreamableHttp


async def main():
    async with MCPServerStreamableHttp(
        name="tickerlayer",
        params={
            "url": "https://mcp.tickerlayer.com/mcp",
            "headers": {"x-api-key": os.environ["TICKERLAYER_API_KEY"]},
        },
    ) as tickerlayer:
        agent = Agent(
            name="Markets",
            instructions="Answer with live market data.",
            mcp_servers=[tickerlayer],
        )
        result = await Runner.run(agent, "How is BTCUSD doing today?")
        print(result.final_output)


asyncio.run(main())
```

## Vercel AI SDK

The AI SDK's MCP client returns the tools in the shape generateText and streamText expect.

```javascript
// npm i ai @ai-sdk/mcp @ai-sdk/anthropic
import { anthropic } from "@ai-sdk/anthropic";
import { createMCPClient } from "@ai-sdk/mcp";
import { generateText, stepCountIs } from "ai";

const tickerlayer = await createMCPClient({
  transport: {
    type: "http",
    url: "https://mcp.tickerlayer.com/mcp",
    headers: { "x-api-key": process.env.TICKERLAYER_API_KEY! },
  },
});

try {
  const { text } = await generateText({
    model: anthropic("claude-sonnet-5-5"),
    tools: await tickerlayer.tools(),
    stopWhen: stepCountIs(5),
    prompt: "How is BTCUSD doing today?",
  });
  console.log(text);
} finally {
  await tickerlayer.close();
}
```

## CrewAI

The MCP adapter from CrewAI Tools hands the tools to any agent in a crew.

```python
# pip install crewai "crewai-tools[mcp]"
import os

from crewai import Agent, Crew, Task
from crewai_tools import MCPServerAdapter

server = {
    "url": "https://mcp.tickerlayer.com/mcp",
    "transport": "streamable-http",
    "headers": {"x-api-key": os.environ["TICKERLAYER_API_KEY"]},
}

with MCPServerAdapter(server) as tools:
    analyst = Agent(
        role="Market analyst",
        goal="Answer questions with live market data",
        backstory="Reads prices, history and market hours from TickerLayer.",
        tools=tools,
    )
    task = Task(
        description="How is BTCUSD doing today?",
        expected_output="A short summary",
        agent=analyst,
    )
    print(Crew(agents=[analyst], tasks=[task]).kickoff())
```

## LlamaIndex

The MCP tool spec converts the tools for a FunctionAgent or any other LlamaIndex agent.

```python
# pip install llama-index-core llama-index-tools-mcp llama-index-llms-anthropic
import asyncio
import os

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

client = BasicMCPClient(
    "https://mcp.tickerlayer.com/mcp",
    headers={"x-api-key": os.environ["TICKERLAYER_API_KEY"]},
)


async def main():
    tools = await McpToolSpec(client=client).to_tool_list_async()
    agent = FunctionAgent(tools=tools, llm=Anthropic(model="claude-sonnet-5-5"))
    print(await agent.run("How is BTCUSD doing today?"))


asyncio.run(main())
```

## Google ADK

An MCP toolset on an LlmAgent. Save it as the agent module and start it with the ADK command line.

```python
# pip install google-adk
# Save as markets/agent.py, then run `adk web` or `adk run markets`.
import os

from google.adk.agents import LlmAgent
from google.adk.tools.mcp_tool import McpToolset, StreamableHTTPConnectionParams

root_agent = LlmAgent(
    model="gemini-3.5-flash",
    name="markets",
    instruction="Answer with live market data from TickerLayer.",
    tools=[
        McpToolset(
            connection_params=StreamableHTTPConnectionParams(
                url="https://mcp.tickerlayer.com/mcp",
                headers={"x-api-key": os.environ["TICKERLAYER_API_KEY"]},
            )
        )
    ],
)
```

## Pydantic AI

An MCP toolset gives a Pydantic AI agent every tool with its input schema.

```python
# pip install "pydantic-ai-slim[anthropic,mcp]"
import os

from fastmcp.client.transports import StreamableHttpTransport
from pydantic_ai import Agent
from pydantic_ai.mcp import MCPToolset

tickerlayer = MCPToolset(
    StreamableHttpTransport(
        "https://mcp.tickerlayer.com/mcp",
        headers={"x-api-key": os.environ["TICKERLAYER_API_KEY"]},
    )
)

agent = Agent("anthropic:claude-sonnet-5-5", toolsets=[tickerlayer])
print(agent.run_sync("How is BTCUSD doing today?").output)
```

## Mastra

Mastra's MCP client prefixes each tool with the server name (tickerlayer_get_snapshot) and hands them to an agent.

```javascript
// npm i @mastra/core @mastra/mcp @ai-sdk/anthropic zod
import { anthropic } from "@ai-sdk/anthropic";
import { Agent } from "@mastra/core/agent";
import { MCPClient } from "@mastra/mcp";

const mcp = new MCPClient({
  servers: {
    tickerlayer: {
      url: new URL("https://mcp.tickerlayer.com/mcp"),
      requestInit: { headers: { "x-api-key": process.env.TICKERLAYER_API_KEY! } },
    },
  },
});

const agent = new Agent({
  id: "markets",
  name: "Markets",
  instructions: "Answer with live market data from TickerLayer.",
  model: anthropic("claude-sonnet-5-5"),
  tools: await mcp.listTools(),
});

const result = await agent.generate("How is BTCUSD doing today?");
console.log(result.text);
await mcp.disconnect();
```

## smolagents

Hugging Face's agent library loads the tools with its MCP client.

```python
# pip install "smolagents[mcp]"
import os

from smolagents import CodeAgent, InferenceClientModel, MCPClient

server = {
    "url": "https://mcp.tickerlayer.com/mcp",
    "transport": "streamable-http",
    "headers": {"x-api-key": os.environ["TICKERLAYER_API_KEY"]},
}

with MCPClient(server) as tools:
    agent = CodeAgent(tools=tools, model=InferenceClientModel())
    print(agent.run("How is BTCUSD doing today?"))
```

## Agno

Agno's MCP toolkit connects over streamable HTTP with your key in the headers.

```python
# pip install agno anthropic "fastmcp>=4,<5"
import asyncio
import os

from agno.agent import Agent
from agno.models.anthropic import Claude
from agno.tools.mcp import MCPTools, StreamableHTTPClientParams


async def main():
    params = StreamableHTTPClientParams(
        url="https://mcp.tickerlayer.com/mcp",
        headers={"x-api-key": os.environ["TICKERLAYER_API_KEY"]},
    )
    tickerlayer = MCPTools(transport="streamable-http", server_params=params)
    async with tickerlayer:
        agent = Agent(model=Claude(id="claude-sonnet-5-5"), tools=[tickerlayer])
        await agent.aprint_response("How is BTCUSD doing today?")


asyncio.run(main())
```

## Other frameworks

Any framework or runtime whose MCP client can send a custom HTTP header connects the same way: the endpoint URL plus an `x-api-key` header. Clients that sign in with OAuth need only the URL. Configuration for Claude, ChatGPT, Cursor, Gemini, VS Code and the OpenAI API is on the [MCP server page](https://tickerlayer.com/docs/mcp#connect).
