Agent frameworks

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

const hyperdex = await createMCPClient({
  transport: {
    type: "http",
    url: "https://hyperdex.hypervect.com/mcp",
    headers: { Authorization: `Bearer ${process.env.HYPERDEX_API_KEY}` },
  },
});
try {
  const { text } = await generateText({
    model: "anthropic/claude-sonnet-5.5",
    tools: await hyperdex.tools(),
    stopWhen: isStepCount(10),
    prompt: "Which deals have gone quiet?",
  });
  console.log(text);
} finally {
  await hyperdex.close();
}

import os, asyncio
from langchain_mcp_adapters.client import MultiServerMCPClient
from langchain.agents import create_agent

async def main():
    client = MultiServerMCPClient({
        "hyperdex": {
            "transport": "streamable_http",
            "url": "https://hyperdex.hypervect.com/mcp",
            "headers": {"Authorization": f"Bearer {os.environ['HYPERDEX_API_KEY']}"},
        }
    })
    agent = create_agent("openai:gpt-4.1", await client.get_tools())  # your model
    print(await agent.ainvoke({"messages": "List my open tasks"}))

asyncio.run(main())

import os
from crewai import Agent
from crewai.mcp import MCPServerHTTP

crm_agent = Agent(
    role="CRM operator",
    goal="Keep our customer records accurate and up to date",
    backstory="Works the Hyperdex task queue for the sales team",
    mcps=[MCPServerHTTP(
        url="https://hyperdex.hypervect.com/mcp",
        headers={"Authorization": f"Bearer {os.environ['HYPERDEX_API_KEY']}"},
    )],
)

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

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

export const crmAgent = new Agent({
  id: "crm-agent",
  name: "CRM Agent",
  instructions: "Use Hyperdex as your memory of every customer.",
  model: "openai/gpt-5.6-sol",
  tools: await mcp.listTools(),
});

import os, asyncio
from llama_index.tools.mcp import BasicMCPClient, McpToolSpec
from llama_index.core.agent.workflow import FunctionAgent
from llama_index.llms.openai import OpenAI

async def main():
    client = BasicMCPClient("https://hyperdex.hypervect.com/mcp", headers={"Authorization": f"Bearer {os.environ['HYPERDEX_API_KEY']}"})
    tools = await McpToolSpec(client=client).to_tool_list_async()
    agent = FunctionAgent(name="crm", description="CRM agent", tools=tools,
                          llm=OpenAI(model="gpt-4o"),  # your model
                          system_prompt="Use Hyperdex as your memory of every customer.")
    print(await agent.run("List my open tasks"))

asyncio.run(main())

import os
from pydantic_ai import Agent
from pydantic_ai.mcp import MCPToolset

hyperdex = MCPToolset("https://hyperdex.hypervect.com/mcp", headers={"Authorization": f"Bearer {os.environ['HYPERDEX_API_KEY']}"})
agent = Agent("openai:gpt-5", toolsets=[hyperdex])  # your model

print(agent.run_sync("List my open tasks").output)

import os
from google.adk.agents import LlmAgent
from google.adk.tools.mcp_tool import McpToolset
from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPConnectionParams

root_agent = LlmAgent(
    model="gemini-flash-latest",
    name="crm_agent",
    instruction="Use Hyperdex as your memory of every customer.",
    tools=[McpToolset(connection_params=StreamableHTTPConnectionParams(
        url="https://hyperdex.hypervect.com/mcp",
        headers={"Authorization": f"Bearer {os.environ['HYPERDEX_API_KEY']}"},
    ))],
)

import os, asyncio
from agent_framework import Agent, MCPStreamableHTTPTool
from agent_framework.openai import OpenAIChatClient

async def main():
    async with (
        MCPStreamableHTTPTool(
            name="hyperdex",
            url="https://hyperdex.hypervect.com/mcp",
            static_headers={"Authorization": f"Bearer {os.environ['HYPERDEX_API_KEY']}"},
        ) as hyperdex,
        Agent(client=OpenAIChatClient(), name="CRMAgent",
              instructions="Use Hyperdex as your memory of every customer.") as agent,
    ):
        print(await agent.run("List my open tasks", tools=hyperdex))

asyncio.run(main())

import os
from strands import Agent
from strands.tools.mcp import MCPClient

hyperdex = MCPClient(url="https://hyperdex.hypervect.com/mcp", headers={"Authorization": f"Bearer {os.environ['HYPERDEX_API_KEY']}"})
with hyperdex:
    agent = Agent(tools=hyperdex.list_tools_sync())
    agent("List my open tasks")

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

async with MCPServerStreamableHttp(
    name="hyperdex",
    params={"url": "https://hyperdex.hypervect.com/mcp", "headers": {"Authorization": f"Bearer {os.environ['HYPERDEX_API_KEY']}"}},
) as hyperdex:
    agent = Agent(name="Sales assistant", mcp_servers=[hyperdex])
    result = await Runner.run(agent, "Which deals have gone quiet?")
    print(result.final_output)

import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";

const client = new Client({ name: "my-agent", version: "1.0.0" });
await client.connect(
  new StreamableHTTPClientTransport(new URL("https://hyperdex.hypervect.com/mcp"), {
    requestInit: { headers: { Authorization: `Bearer ${process.env.HYPERDEX_API_KEY}` } },
  }),
);
const result = await client.callTool({ name: "search", arguments: { query: "acme" } });
await client.close();