Agent frameworks

import asyncio
import os

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


async def main() -> None:
    async with MCPServerStreamableHttp(
        name="spicrawl",
        params={
            "url": "https://mcp.spicrawl.com/mcp",
            "headers": {"Authorization": f"Bearer {os.environ['SPICRAWL_API_KEY']}"},
        },
        cache_tools_list=True,
        tool_filter=create_static_tool_filter(
            allowed_tool_names=["spicrawl_scrape", "spicrawl_batch_submit"]
        ),
    ) as server:
        agent = Agent(
            name="Page reader",
            instructions="Use the Spicrawl tools to read web pages.",
            mcp_servers=[server],
        )
        result = await Runner.run(
            agent,
            "Read https://example.com/pricing as markdown and list the plans.",
        )
        print(result.final_output)


asyncio.run(main())

import { createMCPClient } from "@ai-sdk/mcp";
import { openai } from "@ai-sdk/openai";
import { generateText, isStepCount } from "ai";

const mcp = await createMCPClient({
  transport: {
    type: "http",
    url: "https://mcp.spicrawl.com/mcp",
    headers: { Authorization: `Bearer ${process.env.SPICRAWL_API_KEY}` },
  },
});

try {
  const all = await mcp.tools();
  const keep = ["spicrawl_scrape", "spicrawl_batch_submit"];
  const tools = Object.fromEntries(
    Object.entries(all).filter(([name]) => keep.includes(name)),
  );

  const { text } = await generateText({
    model: openai("gpt-5"),
    tools,
    stopWhen: isStepCount(5),
    prompt: "Read https://example.com/pricing as markdown and list the plans.",
  });
  console.log(text);
} finally {
  await mcp.close();
}

import asyncio
import os

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


async def main() -> None:
    client = MultiServerMCPClient(
        {
            "spicrawl": {
                "transport": "streamable_http",
                "url": "https://mcp.spicrawl.com/mcp",
                "headers": {"Authorization": f"Bearer {os.environ['SPICRAWL_API_KEY']}"},
            }
        }
    )
    keep = {"spicrawl_scrape", "spicrawl_batch_submit"}
    tools = [t for t in await client.get_tools() if t.name in keep]

    agent = create_agent("openai:gpt-4.1", tools)
    result = await agent.ainvoke(
        {"messages": "Read https://example.com/pricing as markdown and list the plans."}
    )
    print(result["messages"][-1].content)


asyncio.run(main())

import os

from crewai import Agent, Crew, Task
from crewai.mcp import MCPServerHTTP
from crewai.mcp.filters import create_static_tool_filter

reader = Agent(
    role="Page reader",
    goal="Read web pages with the Spicrawl tools and report what they say",
    backstory="You fetch pages as markdown and summarize them accurately.",
    mcps=[
        MCPServerHTTP(
            url="https://mcp.spicrawl.com/mcp",
            headers={"Authorization": f"Bearer {os.environ['SPICRAWL_API_KEY']}"},
            streamable=True,
            cache_tools_list=True,
            tool_filter=create_static_tool_filter(
                allowed_tool_names=["spicrawl_scrape", "spicrawl_batch_submit"]
            ),
        )
    ],
)

task = Task(
    description="Read https://example.com/pricing as markdown and list the plans.",
    expected_output="A list of the plan names on the page.",
    agent=reader,
)

result = Crew(agents=[reader], tasks=[task]).kickoff()
print(result)

import asyncio
import os

from google.adk.agents import LlmAgent
from google.adk.runners import InMemoryRunner
from google.adk.tools.mcp_tool import McpToolset, StreamableHTTPConnectionParams
from google.genai import types


async def main() -> None:
    toolset = McpToolset(
        connection_params=StreamableHTTPConnectionParams(
            url="https://mcp.spicrawl.com/mcp",
            headers={"Authorization": f"Bearer {os.environ['SPICRAWL_API_KEY']}"},
        ),
        tool_filter=["spicrawl_scrape", "spicrawl_batch_submit"],
    )
    agent = LlmAgent(
        name="page_reader",
        model="gemini-2.5-flash",
        instruction="Use the Spicrawl tools to read web pages.",
        tools=[toolset],
    )
    runner = InMemoryRunner(agent=agent, app_name="spicrawl_example")
    session = await runner.session_service.create_session(
        app_name="spicrawl_example", user_id="user"
    )
    message = types.Content(
        role="user",
        parts=[types.Part(text="Read https://example.com/pricing as markdown and list the plans.")],
    )
    try:
        async for event in runner.run_async(
            user_id="user", session_id=session.id, new_message=message
        ):
            if event.is_final_response() and event.content:
                print(event.content.parts[0].text)
    finally:
        await toolset.close()


asyncio.run(main())

import { Agent } from "@mastra/core/agent";
import { MCPClient } from "@mastra/mcp";

const mcp = new MCPClient({
  servers: {
    spicrawl: {
      url: new URL("https://mcp.spicrawl.com/mcp"),
      requestInit: {
        headers: { Authorization: `Bearer ${process.env.SPICRAWL_API_KEY}` },
      },
    },
  },
});

const agent = new Agent({
  id: "page-reader",
  name: "Page reader",
  instructions: "Use the Spicrawl tools to read web pages.",
  model: "openai/gpt-5",
  tools: await mcp.listTools(),
});

try {
  const result = await agent.generate(
    "Read https://example.com/pricing as markdown and list the plans.",
  );
  console.log(result.text);
} finally {
  await mcp.disconnect();
}

import os

from smolagents import CodeAgent, InferenceClientModel, MCPClient

server_parameters = {
    "url": "https://mcp.spicrawl.com/mcp",
    "transport": "streamable-http",
    "headers": {"Authorization": f"Bearer {os.environ['SPICRAWL_API_KEY']}"},
}

with MCPClient(server_parameters, structured_output=True) as tools:
    tools = [t for t in tools if t.name in {"spicrawl_scrape", "spicrawl_batch_submit"}]
    agent = CodeAgent(tools=tools, model=InferenceClientModel())
    print(agent.run("Read https://example.com/pricing as markdown and list the plans."))