The N×M Integration Problem: Solved by MCP TypeScript SDK

The MCP TypeScript SDK is a crucial framework for developing AI agents that can interact reliably with real-time financial data and complex business logic. It standardizes the communication protocol between AI models and external tools, reducing integration complexity from N×M to a manageable 1×1 interface, ensuring type safety and robust error handling.

Introduction: Unlocking Financial AI with Standardized Integration

The promise of artificial intelligence in finance hinges critically on an AI agent's ability to access, interpret, and act upon diverse, real-time data sources. However, the path to achieving this robust integration is frequently fraught with complexity. Developers building advanced financial AI agents often encounter the N×M integration problem: 'N' representing the number of AI models or agents, and 'M' representing the multitude of external data sources, APIs, and proprietary systems. Each new integration demands custom code, unique authentication, bespoke data parsing, and meticulous error handling, leading to a sprawling, brittle, and difficult-to-maintain codebase.

This challenge is particularly acute in the financial sector, where data sources range from real-time stock quotes and trading volumes to fundamental financial statements, macroeconomic indicators, geopolitical events, and social sentiment feeds. A typical financial AI application might need to query a dozen different APIs, each with its own quirks and data formats. Manually managing these integrations for multiple AI agents creates a compounding complexity that stifles innovation and slows development cycles. The Model Context Protocol (MCP) emerges as a transformative solution, offering a standardized, unified interface that reduces this N×M problem to a far simpler 1×1 interaction between the AI agent and the MCP framework. The MCP TypeScript SDK provides the developer-centric tools to implement this paradigm shift, bringing type safety, robust tool orchestration, and streamlined context management to financial AI applications.

This complete developer reference delves into the MCP TypeScript SDK, showcasing how it empowers developers to build sophisticated financial AI agents that can leverage a rich ecosystem of tools with unprecedented ease and reliability. We will explore its core concepts, practical implementation for financial data analysis, and advanced techniques, demonstrating how VIMO Research leverages this protocol to power its cutting-edge financial intelligence platform.

Understanding the N×M Problem in Financial AI Architectures

In the evolving landscape of AI-driven finance, agents are increasingly expected to perform complex tasks: from executing algorithmic trades based on real-time market shifts to generating comprehensive investment reports incorporating fundamental, technical, and sentiment analysis. Accomplishing these tasks requires interaction with a diverse array of external systems. Consider an AI agent designed to identify undervalued stocks. It might need to:

1. Fetch current stock prices from a market data API (e.g., Bloomberg Open API).
2. Retrieve historical financial statements (income, balance sheet, cash flow) from a financial data provider (e.g., S&P Global, Refinitiv).
3. Analyze recent news sentiment from a news aggregator API.
4. Access macroeconomic indicators from a central bank or government data portal.
5. Query proprietary internal databases for analyst ratings or historical performance metrics.

Each of these interactions represents a distinct integration point. If an organization deploys ten such AI agents, and each agent requires access to five different external data sources, the total number of unique integration pathways can quickly escalate. This scenario generates a significant overhead in terms of API key management, rate limit handling, data serialization/deserialization, and error recovery specific to each data source. Studies show that integration challenges account for up to 40% of development time in complex enterprise AI projects, a substantial drain on resources and a major impediment to speed-to-market.

Furthermore, traditional integration methods often involve brittle, hardcoded API calls embedded directly within the agent's logic or a thin wrapper layer. This tight coupling makes the system difficult to scale, update, and debug. When an API changes its schema, or a new data source is introduced, extensive modifications are required across multiple parts of the codebase. The N×M problem highlights this exponential increase in complexity, demonstrating why a standardized protocol for tool interaction is not merely an optimization but a fundamental necessity for scalable and robust financial AI systems.

The Model Context Protocol (MCP) Paradigm Shift

The Model Context Protocol (MCP) introduces a revolutionary approach to AI agent-tool interaction by abstracting away the underlying complexities of diverse external systems. Instead of directly calling various APIs, an AI agent communicates solely with the MCP framework. This framework, in turn, orchestrates the execution of 'tools' that encapsulate the logic for interacting with external resources. This design shifts the integration paradigm from an N×M spaghetti of direct connections to a streamlined 1×1 model: one agent interacts with one MCP instance, which then manages all 'M' tools.

🤖 VIMO Research Note: The core philosophy of MCP is to provide LLMs with a structured, consistent 'context' – a collection of available tools and their capabilities – and to process their 'tool calls' into actionable executions, returning 'observations' back into the model's context. This dramatically improves reliability and reduces hallucination related to tool usage.

At the heart of MCP are three fundamental concepts:

• Agents: These are the AI models (e.g., LLMs) that generate tool calls based on their understanding of the context and available tools. They express their intent by requesting specific tools with parameters.
• Tools: These are functions or services that perform specific actions or retrieve data from external systems. Each tool has a clearly defined schema (inputs, outputs, description) that the agent can understand. Examples in finance might include get_stock_price(ticker: string) or analyze_financial_report(company_id: string).
• Context: This is the dynamic environment provided to the agent, containing the definitions of available tools, historical observations (results from previous tool calls), and the current conversational state. The MCP SDK handles the intricate process of injecting tool definitions and observations into the LLM's prompt in a structured, consistent manner, ensuring the LLM always has the most relevant information to make its decisions.

By standardizing how agents discover and utilize tools, MCP eliminates the need for agents to understand the specifics of each external API. Instead, they operate at a higher level of abstraction, requesting a 'stock analysis' rather than knowing the exact sequence of API calls needed to retrieve prices, news, and financials. This not only simplifies agent development but also significantly enhances the robustness and maintainability of the entire system.

Core Concepts of the MCP TypeScript SDK

The MCP TypeScript SDK provides a robust and type-safe framework for building agents and tools that adhere to the Model Context Protocol. Its design emphasizes developer experience, leveraging TypeScript's strong typing to ensure correctness and reduce common integration errors. Key components of the SDK include createAgent, createTool, and the `Context` object.

1. createAgent and AgentConfig

The createAgent function is the entry point for defining and configuring an AI agent within the MCP ecosystem. It takes an AgentConfig object, which specifies how the agent interacts with the underlying LLM and the available tools. This configuration typically includes:

The power of createAgent lies in its ability to abstract away the complexities of prompt engineering and tool invocation. Developers define what the agent can do by providing tools, and the SDK handles the communication protocol.

2. createTool and ToolConfig

Tools are the building blocks of an MCP system. The createTool function allows developers to define these actions or data retrievals in a type-safe manner. A ToolConfig object for a financial tool typically includes:

Here's a simplified example of defining a financial analysis tool:

import { createTool } from '@model-context-protocol/sdk';

const getStockAnalysisTool = createTool({
  name: 'get_stock_analysis',
  description: 'Retrieves comprehensive financial analysis for a given stock ticker, including real-time price, key financial ratios, and recent news sentiment.',
  parameters: {
    type: 'object',
    properties: {
      ticker: {
        type: 'string',
        description: 'The stock ticker symbol (e.g., VCB for Vietcombank).'
      },
      includeNewsSentiment: {
        type: 'boolean',
        description: 'Whether to include recent news sentiment analysis. Defaults to false.',
        default: false
      }
    },
    required: ['ticker']
  },
  execute: async (params: { ticker: string; includeNewsSentiment?: boolean }) => {
    // In a real scenario, this would call multiple APIs (e.g., market data, news sentiment)
    console.log(`Executing get_stock_analysis for ${params.ticker}`);
    const price = Math.random() * 100 + 50; // Mock price
    const peRatio = (Math.random() * 20 + 10).toFixed(2); // Mock P/E Ratio
    let sentiment = 'N/A';

    if (params.includeNewsSentiment) {
      sentiment = Math.random() > 0.6 ? 'Positive' : (Math.random() > 0.3 ? 'Neutral' : 'Negative');
    }

    return {
      ticker: params.ticker,
      currentPrice: price.toFixed(2),
      peRatio: parseFloat(peRatio),
      marketCap: (price * 1_000_000_000).toFixed(0), // Mock market cap
      sentiment: sentiment,
      lastUpdated: new Date().toISOString()
    };
  },
});

// You can explore VIMO's 22 MCP tools at vimo.cuthongthai.vn/mcp-server

3. The Context Object and Observations

The Context object is the central state management mechanism within MCP. It encapsulates everything an AI agent needs to know about its environment and prior interactions. When an agent requests a tool call, the SDK executes the tool, and the result is encapsulated as an 'observation' within the Context. This observation is then fed back to the LLM, enabling it to make informed subsequent decisions.

This iterative process—agent calls tool, tool executes, observation is added to context, agent considers new context—forms a robust reasoning loop. The SDK efficiently manages the context window for LLMs, ensuring that relevant tool descriptions and observations are always present without overwhelming the model with redundant information. This mechanism is critical for complex financial analysis where sequential steps and cumulative information are essential for accurate insights.

Building Financial Tools with the SDK: A Practical Example

Developing financial applications with the MCP TypeScript SDK streamlines the process of integrating complex data and analytical capabilities into AI agents. Let's consider a practical scenario where an agent needs to perform a multi-step financial analysis, starting with a stock overview and then diving into its fundamental health.

Scenario: Comprehensive Stock Health Check

An AI agent is tasked with providing a 'health check' for a given company. This requires not only fetching basic market data but also analyzing its recent financial statements and understanding broader market sentiment. Here, we can leverage VIMO's pre-built MCP tools to abstract away the direct API calls.

First, the agent needs tools for market overview and financial statement analysis. VIMO provides robust tools like get_market_overview and get_financial_statements that encapsulate the complexities of fetching and parsing this data.

import { createAgent, createTool, AgentRuntime } from '@model-context-protocol/sdk';

// Assuming VIMO's tools are loaded/imported as 'vimoTools'
// For demonstration, let's mock two VIMO-like tools:
const getMarketOverviewTool = createTool({
  name: 'get_market_overview',
  description: 'Retrieves current market data for a given stock, including price, volume, and daily change.',
  parameters: {
    type: 'object',
    properties: { ticker: { type: 'string', description: 'Stock ticker symbol' } },
    required: ['ticker']
  },
  execute: async ({ ticker }: { ticker: string }) => {
    console.log(`Fetching market overview for ${ticker}...`);
    // Simulate API call to VIMO's market overview service
    return {
      ticker: ticker,
      price: (Math.random() * 1000 + 100).toFixed(2),
      volume: Math.floor(Math.random() * 10_000_000) + 1_000_000,
      change: (Math.random() * 10 - 5).toFixed(2),
      changePercentage: (Math.random() * 10 - 5).toFixed(2) + '%'
    };
  }
});

const getFinancialStatementsTool = createTool({
  name: 'get_financial_statements',
  description: 'Fetches the latest financial statements (Income Statement, Balance Sheet, Cash Flow) for a company.',
  parameters: {
    type: 'object',
    properties: {
      ticker: { type: 'string', description: 'Stock ticker symbol' },
      statementType: { type: 'string', enum: ['income', 'balance', 'cashflow'], description: 'Type of financial statement' },
      period: { type: 'string', enum: ['quarterly', 'annual'], default: 'annual', description: 'Reporting period' }
    },
    required: ['ticker', 'statementType']
  },
  execute: async ({ ticker, statementType, period }: { ticker: string; statementType: string; period?: string }) => {
    console.log(`Fetching ${statementType} statement for ${ticker} (${period})...`);
    // Simulate API call to VIMO's financial statement analyzer
    const data: Record = {
      ticker,
      statementType,
      period: period || 'annual',
      data: {}
    };
    if (statementType === 'income') {
      data.data = {
        revenue: (Math.random() * 10_000 + 1_000).toFixed(2), // in millions
        netIncome: (Math.random() * 1_000 + 100).toFixed(2),
        eps: (Math.random() * 5 + 0.5).toFixed(2)
      };
    } else if (statementType === 'balance') {
      data.data = {
        totalAssets: (Math.random() * 20_000 + 5_000).toFixed(2),
        totalLiabilities: (Math.random() * 10_000 + 2_000).toFixed(2),
        equity: (Math.random() * 10_000 + 3_000).toFixed(2)
      };
    }
    return data;
  }
});

// Create an agent with access to these tools
const financialAnalystAgent = createAgent({
  name: 'FinancialAnalyst',
  tools: [getMarketOverviewTool, getFinancialStatementsTool],
  // In a real application, you would connect to an actual LLM provider
  // For demonstration, we'll use a mock LLM that calls tools based on a simple heuristic
  llm: {
    call: async (context, tools) => {
      const lastObservation = context.observations[context.observations.length - 1];
      const initialPrompt = context.messages[0]?.content;

      if (initialPrompt?.includes('health check') && !lastObservation) {
        // First turn: call market overview
        return { toolCall: { name: 'get_market_overview', parameters: { ticker: 'VCB' } } };
      } else if (lastObservation && lastObservation.toolName === 'get_market_overview') {
        // Second turn: call income statement after market overview
        return { toolCall: { name: 'get_financial_statements', parameters: { ticker: 'VCB', statementType: 'income' } } };
      } else if (lastObservation && lastObservation.toolName === 'get_financial_statements' && lastObservation.parameters.statementType === 'income') {
        // Third turn: call balance sheet after income statement
        return { toolCall: { name: 'get_financial_statements', parameters: { ticker: 'VCB', statementType: 'balance' } } };
      } else if (lastObservation && lastObservation.toolName === 'get_financial_statements' && lastObservation.parameters.statementType === 'balance') {
        // Fourth turn: respond with a summary after all data is gathered
        const overview = context.observations.find(obs => obs.toolName === 'get_market_overview')?.result;
        const income = context.observations.find(obs => obs.toolName === 'get_financial_statements' && obs.parameters.statementType === 'income')?.result;
        const balance = context.observations.find(obs => obs.toolName === 'get_financial_statements' && obs.parameters.statementType === 'balance')?.result;

        return { 
          response: `Completed financial health check for VCB:\n` +
                    `Market Overview: Price ${overview?.price}, Volume ${overview?.volume}\n` +
                    `Latest Income: Revenue ${income?.data?.revenue}, Net Income ${income?.data?.netIncome}\n` +
                    `Latest Balance: Assets ${balance?.data?.totalAssets}, Liabilities ${balance?.data?.totalLiabilities}\n` +
                    `Based on this, VCB appears to be a company with significant market activity and a solid financial base.`
        };
      }
      return { response: 'I am unable to proceed.' };
    }
  }
});

async function runHealthCheck() {
  const runtime = new AgentRuntime(financialAnalystAgent);
  const result = await runtime.run('Perform a financial health check for VCB.');
  console.log('\nFinal Agent Response:', result);
}

runHealthCheck();

This example demonstrates how an agent can sequentially call multiple tools, with each subsequent call leveraging the observations from previous executions. The MCP SDK handles feeding the results of get_market_overview into the agent's context, allowing it to then intelligently decide to call get_financial_statements for further detail. This multi-turn interaction is critical for sophisticated financial analysis, where decisions are often built upon a cascade of data points and interpretations.

Comparison: MCP vs. Direct API Calls vs. LangChain Tooling

To highlight the advantages of the MCP TypeScript SDK, let's compare its approach to traditional direct API calls and other AI framework tooling, such as those found in LangChain.

As the table illustrates, the MCP TypeScript SDK stands out by prioritizing type safety and a rigidly defined protocol for agent-tool interaction. This ensures that the agent always receives consistent, validated data, and that tool calls adhere to their defined schemas, significantly reducing runtime errors and development overhead, especially in the high-stakes financial domain. While other frameworks provide tool abstractions, MCP's emphasis on a formal protocol and TypeScript's compile-time checks offers a superior level of reliability and maintainability.

Integrating Real-Time Data Sources with MCP

One of the most compelling applications of the MCP TypeScript SDK in finance is its ability to seamlessly integrate with real-time data sources. Financial markets operate at high velocity, and AI agents need immediate access to streaming data for timely decision-making. The MCP's tool-centric architecture is ideally suited for this, allowing developers to encapsulate the complexities of real-time data ingestion within well-defined tools.

Consider the need to access real-time foreign flow data or track 'whale' activities (large institutional trades). Direct integration with multiple data providers, managing WebSocket connections, and parsing continuous data streams can be challenging. With MCP, these complexities are hidden behind simple, callable tools. For instance, VIMO Research provides a suite of 22 MCP tools specifically designed for the Vietnamese stock market, including get_foreign_flow, get_whale_activity, and get_sector_heatmap. These tools abstract the intricate data retrieval and processing, presenting a clean interface to the AI agent.

An AI agent designed to monitor market anomalies could be configured with a get_realtime_quotes tool that, when called, subscribes to a data feed or queries a low-latency API. The observations returned would then update the agent's context, allowing it to react instantly to price spikes, volume surges, or significant foreign capital movements. The benefit is twofold: developers can focus on agent logic rather than data plumbing, and the system becomes far more resilient to changes in underlying data provider APIs, as only the tool's implementation needs modification.

🤖 VIMO Research Note: VIMO’s MCP Server provides a centralized hub for these financial tools, enabling developers to simply include them in their agent configurations without worrying about individual API keys or data normalization. This dramatically accelerates the development of advanced trading bots and analytical platforms. You can explore VIMO's AI Stock Screener to see some of these tools in action.

Furthermore, the MCP SDK's asynchronous execute method within createTool is perfectly suited for handling the non-blocking nature of real-time data operations. This ensures that an agent's reasoning loop is not stalled waiting for potentially slow data fetches, maintaining responsiveness and enabling efficient parallel processing of observations. This capability is paramount in high-frequency trading or real-time risk management scenarios, where milliseconds can significantly impact outcomes.

Advanced Techniques and Best Practices

While the MCP TypeScript SDK simplifies agent-tool interaction, mastering advanced techniques and adhering to best practices can unlock even greater potential for robust and performant financial AI applications.

1. Robust Error Handling and Retry Mechanisms

External APIs in finance are not infallible. Network glitches, rate limits, and transient service outages are common. Each tool's execute function should implement comprehensive error handling, ideally with exponential backoff and retry logic. The MCP framework allows tools to return structured error observations, which the agent can then interpret to decide on alternative actions or re-attempts. For example, if get_stock_analysis fails due to a rate limit, the agent might decide to wait and retry, or to use a less comprehensive fallback tool.

2. Asynchronous Tool Execution and Parallelism

Many financial analysis tasks involve fetching multiple independent pieces of information simultaneously. The MCP SDK's asynchronous nature facilitates this. Developers can design agents that, in a single turn, can issue multiple tool calls in parallel (if the LLM supports it, or through custom orchestration logic). For instance, an agent could simultaneously call get_foreign_flow and get_whale_activity for the same ticker. The SDK's runtime efficiently manages these concurrent executions, feeding all observations back to the agent once completed, significantly reducing latency for complex queries.

3. Optimizing Context Window Management

Large Language Models have finite context windows. While MCP automatically manages the inclusion of tool definitions and observations, it's crucial for developers to be mindful of context length. This can involve:

For example, instead of feeding an entire news article, a summarize_news tool could extract only the sentiment and key entities, preserving context for the agent's core reasoning.

4. Versioning and Tool Evolution

Financial data sources and analytical methodologies evolve. Implementing versioning for tools (e.g., get_stock_analysis_v1, get_stock_analysis_v2) allows for backward compatibility and graceful upgrades. This is especially important for continuous deployment environments where an agent might need to access historical versions of data or analytical approaches. The structured nature of MCP tools, with their explicit JSON Schemas, makes managing these evolutionary changes far more manageable than with ad-hoc API integrations.

How to Get Started with the MCP TypeScript SDK

Embarking on your journey with the MCP TypeScript SDK is straightforward. This step-by-step guide will help you set up your development environment and create your first agent and tool.

Step 1: Initialize Your Project

Ensure you have Node.js (v18 or later) and npm or Yarn installed. Create a new TypeScript project:

mkdir my-financial-agent
cd my-financial-agent
npm init -y
npm install typescript @model-context-protocol/sdk
npx tsc --init

Modify your tsconfig.json to include "resolveJsonModule": true and adjust "target" to "es2022" or higher, and "module" to "NodeNext".

Step 2: Define Your First Tool

Create a file named src/tools/getRealtimePrice.ts and add a simple tool to fetch a mock real-time stock price:

import { createTool } from '@model-context-protocol/sdk';

export const getRealtimePriceTool = createTool({
  name: 'get_realtime_price',
  description: 'Fetches the current real-time trading price for a given stock ticker.',
  parameters: {
    type: 'object',
    properties: {
      ticker: {
        type: 'string',
        description: 'The stock ticker symbol (e.g., FPT).' // FPT for FPT Corporation
      }
    },
    required: ['ticker']
  },
  execute: async ({ ticker }: { ticker: string }) => {
    console.log(`Fetching real-time price for ${ticker}...`);
    // In a real scenario, this would call a live market data API
    const price = (Math.random() * 50 + 50).toFixed(2);
    return {
      ticker: ticker,
      price: parseFloat(price),
      timestamp: new Date().toISOString()
    };
  }
});

Step 3: Create Your Agent

Create a file named src/agent.ts. Here, you'll define your agent and provide it with the tool you just created. For simplicity, we'll use a mock LLM connector that directly calls the tool based on a heuristic, but in production, this would integrate with a service like OpenAI or Anthropic.

import { createAgent, AgentRuntime } from '@model-context-protocol/sdk';
import { getRealtimePriceTool } from './tools/getRealtimePrice';

const simplePriceAgent = createAgent({
  name: 'SimplePriceAgent',
  tools: [getRealtimePriceTool],
  llm: {
    call: async (context, tools) => {
      const initialPrompt = context.messages[0]?.content;
      if (initialPrompt?.includes('price') && !context.observations.length) {
        // If the prompt asks for price and no observations yet, call the tool
        return { toolCall: { name: 'get_realtime_price', parameters: { ticker: 'FPT' } } };
      } else if (context.observations.length > 0) {
        // After getting an observation, respond with the price
        const priceObservation = context.observations[0];
        return {
          response: `The current price for ${priceObservation.result.ticker} is ${priceObservation.result.price} as of ${new Date(priceObservation.result.timestamp).toLocaleTimeString()}.`
        };
      }
      return { response: 'I can only fetch real-time prices.' };
    }
  }
});

async function main() {
  const runtime = new AgentRuntime(simplePriceAgent);
  console.log('Running agent...');
  const result = await runtime.run('What is the current price of FPT?');
  console.log('\nAgent says:', result);
}

main();

Step 4: Run Your Agent

Compile and run your TypeScript project:

npx tsc
node dist/agent.js

You should see output similar to:

Running agent...
Fetching real-time price for FPT...

Agent says: The current price for FPT is 75.23 as of 10:30:45 AM. (Price and time will vary)

This demonstrates a complete, albeit simple, agent-tool interaction using the MCP TypeScript SDK. From here, you can expand by adding more sophisticated tools, integrating with actual LLM providers, and building more complex agent behaviors. Remember, the core of MCP lies in defining clear tool schemas and allowing the LLM to orchestrate their usage based on the provided context.

Conclusion: The Future of Financial AI Integration

The N×M integration problem has long been a formidable barrier to the widespread adoption and scalability of advanced AI agents in the financial sector. The Model Context Protocol (MCP), specifically through its robust TypeScript SDK, offers a definitive solution. By standardizing the communication between AI models and external tools, MCP drastically simplifies integration complexity, moving from a tangled web of bespoke connections to a streamlined, protocol-driven 1×1 interaction.

The MCP TypeScript SDK empowers developers with type safety, comprehensive context management, and a clear framework for building and orchestrating tools that interact with diverse financial data sources. Whether retrieving real-time market data, analyzing intricate financial statements, or monitoring sophisticated trading signals, MCP provides the foundation for reliable, scalable, and maintainable AI applications. VIMO Research leverages this advanced protocol to deliver superior financial intelligence, enabling our AI agents to process vast amounts of data and execute complex analytical tasks with precision.

As AI continues to mature, frameworks like the MCP TypeScript SDK will be indispensable for bridging the gap between powerful language models and the actionable, real-world data they need to operate effectively. By adopting MCP, financial institutions and developers can accelerate innovation, reduce development costs, and build the next generation of intelligent financial systems with confidence.

Explore VIMO's 22 MCP tools for Vietnam stock intelligence at vimo.cuthongthai.vn/mcp-server

import { createAgent, AgentRuntime } from '@model-context-protocol/sdk';

// Simplified representation of calling VIMO's remote MCP tool
const vimoGetMarketOverviewTool = createTool({
  name: 'get_market_overview',
  description: 'Retrieves current market data for a given stock.',
  parameters: {
    type: 'object',
    properties: { ticker: { type: 'string' } },
    required: ['ticker']
  },
  execute: async ({ ticker }: { ticker: string }) => {
    // In a real scenario, this would be an API call to VIMO's MCP Server
    const response = await fetch(`https://vimo.cuthongthai.vn/api/mcp/tools/get_market_overview?ticker=${ticker}`);
    return response.json();
  }
});

const analystAgent = createAgent({
  name: 'AnalystAgent',
  tools: [vimoGetMarketOverviewTool],
  llm: { /* ... LLM connector details ... */ }
});

// Agent execution simplified for brevity
// runtime.run('What is the current market overview for HPG?');

Về Tác Giả

Cú Thông Thái

Founder Cú Thông Thái