MCP Tools

import { McpAtp, LlmAgent } from "@iqai/adk";

// Initialize ATP MCP toolset
const atpToolset = McpAtp({
  env: {
    ATP_WALLET_PRIVATE_KEY: process.env.WALLET_PRIVATE_KEY,
    ATP_API_KEY: process.env.ATP_API_KEY,
  },
});

// Get tools and create agent
const tools = await atpToolset.getTools();

const agent = new LlmAgent({
  name: "blockchain_agent",
  model: "gemini-2.5-flash",
  description:
    "An agent that queries blockchain data and interacts with DeFi protocols",
  instruction: "Query blockchain data and interact with DeFi protocols",
  tools,
});

// Always cleanup when done
await atpToolset.close();

import { McpAtp, LlmAgent } from "@iqai/adk";

const atpToolset = McpAtp({
  env: {
    ATP_WALLET_PRIVATE_KEY: process.env.WALLET_PRIVATE_KEY,
    ATP_API_KEY: process.env.ATP_API_KEY,
  },
});

const tools = await atpToolset.getTools();

const blockchainAgent = new LlmAgent({
  name: "blockchain_agent",
  model: "gemini-2.5-flash",
  description:
    "An agent that queries agent tokenomics and ATP platform statistics",
  instruction: "Query agent tokenomics and ATP platform statistics",
  tools,
});

await atpToolset.close();

import { McpAtp, McpNearAgent, McpCoinGecko, LlmAgent } from "@iqai/adk";

// Initialize multiple toolsets
const atpToolset = McpAtp({
  env: {
    ATP_WALLET_PRIVATE_KEY: process.env.WALLET_PRIVATE_KEY,
    ATP_API_KEY: process.env.ATP_API_KEY,
  },
});

const nearToolset = McpNearAgent({
  env: {
    ACCOUNT_ID: process.env.NEAR_ACCOUNT_ID,
    ACCOUNT_KEY: process.env.NEAR_ACCOUNT_KEY,
    NEAR_NETWORK_ID: "testnet",
  },
});

const cryptoToolset = McpCoinGecko();

// Get all tools in parallel
const [atpTools, nearTools, cryptoTools] = await Promise.all([
  atpToolset.getTools(),
  nearToolset.getTools(),
  cryptoToolset.getTools(),
]);

// Create agent with combined tools
const defiAssistantAgent = new LlmAgent({
  name: "defi_assistant_agent",
  model: "gemini-2.5-flash",
  description:
    "A comprehensive DeFi assistant with access to multiple blockchain and market data sources",
  instruction: `You have access to:
    - ATP tools for agent tokenomics and statistics
    - NEAR Protocol tools for blockchain operations
    - CoinGecko for real-time crypto market data
    Use these tools to provide comprehensive DeFi insights`,
  tools: [...atpTools, ...nearTools, ...cryptoTools],
});

// Always cleanup all connections
await Promise.all([
  atpToolset.close(),
  nearToolset.close(),
  cryptoToolset.close(),
]);

new McpToolset(config: McpConfig, toolFilter?: string[] | Function)

import { McpToolset, LlmAgent, type McpConfig } from "@iqai/adk";

const mcpConfig: McpConfig = {
  name: "Filesystem MCP",
  description: "Local file system operations",
  transport: {
    mode: "stdio",
    command: "npx",
    args: ["-y", "@modelcontextprotocol/server-filesystem", "/allowed/path"],
    env: { PATH: process.env.PATH || "" },
  },
};

const toolset = new McpToolset(mcpConfig);
const tools = await toolset.getTools();

const fileAgent = new LlmAgent({
  name: "file_agent",
  model: "gemini-2.5-flash",
  description: "An agent that manages file operations in allowed directories",
  instruction:
    "Manage files in the allowed directory. Always ask before modifying files",
  tools,
});

await toolset.close();

import { McpToolset, LlmAgent, type McpConfig } from "@iqai/adk";

const remoteConfig: McpConfig = {
  name: "Remote API Server",
  description: "Remote MCP server",
  transport: {
    mode: "sse",
    serverUrl: "https://mcp-api.example.com/v1/mcp",
    headers: {
      Authorization: `Bearer ${process.env.MCP_AUTH_TOKEN}`,
    },
  },
};

const toolset = new McpToolset(remoteConfig);
const tools = await toolset.getTools();

const apiAgent = new LlmAgent({
  name: "api_agent",
  model: "gemini-2.5-flash",
  description: "An agent that interacts with remote API endpoints",
  tools,
});

await toolset.close();

# Install the ADK CLI globally
npm install -g @iqai/adk-cli

# Create a new MCP server project using the starter template
adk new --template mcp-starter my-mcp-server

# Navigate to the project directory
cd my-mcp-server

# Install dependencies
pnpm install

# Start the development server (in a separate terminal)
pnpm dev

// src/index.ts
import { FastMCP } from "fastmcp";
import { weatherTool } from "./tools/weather.js";

async function main() {
  const server = new FastMCP({
    name: "Weather MCP Server",
    version: "1.0.0",
  });

  server.addTool(weatherTool);

  await server.start({
    transportType: "stdio",
  });
}

main().catch(console.error);

// src/tools/weather.ts
import { z } from "zod";

export const weatherTool = {
  name: "get_weather",
  description: "Get current weather for a city",
  parameters: z.object({
    city: z.string().describe("City name"),
  }),
  execute: async ({ city }: { city: string }) => {
    // Your weather API logic here
    return { temperature: 72, condition: "Sunny" };
  },
};

import { McpToolset, LlmAgent } from "@iqai/adk";

const customToolset = new McpToolset({
  name: "My Custom Server",
  description: "Custom MCP server with weather tools",
  transport: {
    mode: "stdio",
    command: "node",
    args: ["./my-mcp-server/dist/index.js"],
  },
});

const tools = await customToolset.getTools();

const agent = new LlmAgent({
  name: "weather_agent",
  model: "gemini-2.5-flash",
  description: "An agent with access to custom weather tools",
  tools,
});