---
title: "2026年如何构建Solana AI代理"
description: "一篇技术教程，介绍如何在Solana上构建代理。"
---

# 2026年如何构建Solana AI代理

<ImageBlock
  src="https://media.alchemy.com/1769377861-how-to-build-solana-ai-agents.png"
  alt="一排AI代理面孔,展示Solana AI代理开发"
  width={5760}
  height={2700}
  priority
/>

[AI agent](https://www.alchemy.com/dapps/best/ai-agents)正在改变我们与区块链基础设施交互的方式。这些自主程序可以执行交易、管理投资组合、铸造 NFT,并与 DeFi 协议交互,全部通过自然语言指令完成。这与加密货币早期的用户体验相去甚远。

Solana 已成为 AI agent 开发的主流区块链,[2025 年 12 月占 x402 交易量的 77%](https://x.com/OnchainLu/status/2000971905310834780),这得益于其亚秒级的最终确认速度、可忽略不计的交易成本,以及专为 agentic 应用打造的成熟框架生态。

本指南将介绍如何在 Solana 上构建生产级 AI agent,从选择合适的框架到实现安全的钱包架构。无论你在构建交易机器人、个人链上助手,还是自主的 DeFi 管理器,这里都能找到你需要的技术基础。

## 为什么选择 Solana 开发 AI agent?

AI agent 有潜力改变链上活动并开辟全新的应用场景,这给想要入门的开发者带来了一个关键问题:应该在哪条区块链上构建 AI agent?

答案越来越指向 Solana。一个负责监控市场、执行交易、再平衡投资组合的 agent,每天可能要提交数百笔交易。在 Ethereum 主网上,这样的操作频率可能要花费数千美元的 gas 费。在 Solana 上,只需几分钱。但成本只是起点,Solana 的架构在很多方面都与 agent 的需求高度契合,远不止费用这一点:

- **速度对自主性至关重要:** Agent 需要实时响应市场条件、用户请求和链上事件。Solana 400 毫秒的出块时间和亚秒级的最终确认速度支持紧密的反馈循环。Agent 以循环方式运作:推理该做什么、执行一个操作、观察结果、再次推理。每个"观察"步骤都需要等待交易确认。在出块时间为 12 秒的链上,一个三步工作流意味着超过 36 秒的空闲等待时间,agent 会失去让自主操作显得灵敏的紧密反馈循环。而在 Solana 上,同样的工作流可在 2 秒内确认,让 agent 能够近乎实时地推理和行动。这就是让人感觉像是提交了一个批处理任务的 agent,和感觉像是在身边协作的伙伴的区别。
- **可预测的费用便于规划:** Agent 需要为操作做预算。Solana 的费用模型,每笔交易大约 0.00025 美元,让开发者能够构建仅用极少资金就能持续运行的 agent。拥堵期间的优先费用相比其他链上的 gas 拍卖仍然合理。
- **原生程序可组合性:** Solana 程序可以在单笔交易内原子性地调用其他程序。一个 agent 可以在 [Jupiter](https://www.alchemy.com/dapps/jupiter) 上兑换代币、将兑换所得质押到 Marinade、并铸造一个收据 NFT,这一切都在一次原子操作中完成。这种可组合性正是 Solana agent 与笨拙的顺序工作流的区别所在。当一个 agent 能把多个操作打包进单笔原子交易中,比如兑换代币、提供流动性、质押 LP 仓位,它的执行速度更快(一次确认而非三次)、成本更低(一笔基础费而非三笔)、代码也更简单(步骤之间无需错误处理)。对用户来说,这种差异是天壤之别:让 agent "优化我的收益",它几秒钟内就*直接完成*了,而不是在每个阶段都弹出确认提示,带你走完一个多步骤的流程。
- **生态系统势头:** Solana 上的 AI agent 生态系统自 2024 年底以来呈爆发式增长。[SendAI 的 Solana Agent Kit](https://github.com/sendaifun/solana-agent-kit)、[ElizaOS](https://elizaos.ai/)(前身为 ai16z)、[Crossmint](https://www.alchemy.com/dapps/crossmint) 推出的 [GOAT toolkit](https://github.com/goat-sdk/goat),以及 [Rig](https://rig.rs/) 这样的 Rust 原生框架,共同打造了丰富的开发环境。Jupiter 处理了 Solana DEX 聚合器 90% 的交易量,其 API 专为程序化访问设计,让 agent 能极其方便地接入并利用这些数据。

## 理解 AI agent 技术栈

在深入代码之前,我们先快速概览一下 AI agent 技术栈的各个层级,这有助于你了解针对特定任务应该使用哪些工具。AI agent 技术栈可以概括为 4 个层级:

- **大语言模型(LLM):** LLM 是任何 AI agent 的基础。像 Claude Opus 4.5、GPT-5.2 或 Gemini 2.5 Pro 这样的最新模型提供了自然语言理解和推理能力。它们处理用户请求、解析导入的区块链数据,并决定采取哪些行动。LLM 是让 agent 具有智能、而不仅仅是一个脚本的"大脑"。
- **Agent 框架:** 框架位于 LLM 之上,负责编排 agent 的运作方式。它们管理对话历史、通过系统提示词维持 agent 的"人格"、协调多个工具,并与 Twitter、Discord 或 Telegram 等外部平台集成。ElizaOS 是其中的代表,它将 LLM 集成、记忆管理和多平台客户端整合进一个统一的框架。
- **区块链工具包:** 工具包让 agent 真正具备与 Solana 交互的能力。Solana Agent Kit、GOAT toolkit 及类似库将区块链操作封装为 LLM 可调用的"工具"。当用户说"将 10 个 SOL 兑换成 USDC"时,工具包会将其转换为 Jupiter API 调用、交易构造和提交。

## Agent 框架概览

了解了概念基础后,我们来谈谈将在 2026 年主导 Solana AI agent 开发的四大框架。

### Solana Agent Kit(SendAI)

[Solana Agent Kit](https://github.com/sendaifun/solana-agent-kit) 是构建与 [Solana 生态系统](https://www.alchemy.com/dapps/ecosystem/solana)交互的 agent 最直接的路径。由 SendAI 开发,它提供了 60 多个预构建的操作,涵盖代币操作、NFT 铸造、DeFi 交互等。该工具包能很好地与 LangChain、Vercel AI SDK 及其他流行的 AI 开发框架集成。

SendAI 的模块化插件架构让你只安装需要的部分。代币插件处理 SPL 代币转账和兑换。NFT 插件管理 [Metaplex](https://www.alchemy.com/dapps/metaplex) 操作。DeFi 插件与 Jupiter、[Raydium](https://www.alchemy.com/dapps/raydium) 及其他协议集成。这种模块化使部署保持轻量。

下面是这个框架的初始化过程。首先创建一个钱包,用你的 RPC 和 API 密钥实例化 agent,然后链式加入所需的插件:

<CodeSnippet language="typescript" code={`import { SolanaAgentKit, createVercelAITools, KeypairWallet } from "solana-agent-kit";
import TokenPlugin from "@solana-agent-kit/plugin-token";
import DefiPlugin from "@solana-agent-kit/plugin-defi";

const wallet = new KeypairWallet(keypair);
const agent = new SolanaAgentKit(wallet, "YOUR_RPC_URL", {
OPENAI_API_KEY: "YOUR_OPENAI_API_KEY"
})
.use(TokenPlugin)
.use(DefiPlugin);

const tools = createVercelAITools(agent, agent.actions);`} />
**适合场景:** 希望在全面覆盖 Solana 功能的同时快速原型开发的开发者。该工具包抽象了大部分区块链复杂性,同时在生产环境中仍保持足够的灵活性。

### ElizaOS

[ElizaOS](https://elizaos.ai/) 从 ai16z 项目演变而来,成为一个完整的 agent 操作系统。它专为需要在不同平台(Twitter 机器人、Discord 助手、Telegram 频道)上保持持久人格的自主 agent 而设计。该框架处理记忆、角色定义和多平台部署。

ElizaOS 中的 agent 通过角色 JSON 文件来定义,指定人格、可用操作和行为参数。Solana 插件提供区块链能力,框架负责在各种交互中维持 agent 行为一致性的复杂工作。

使用 CLI 入门非常简单:

<CodeSnippet language="bash" code={`# Install ElizaOS CLI
bun install -g @elizaos/cli

# Create a new agent project

elizaos create my-solana-agent

# Start in development mode

elizaos dev`} />
真正的配置发生在角色文件中。你需要在这里定义 agent 运行在哪些平台、使用哪个 LLM 提供商,以及启用哪些 Solana 能力:

<CodeSnippet
  language="json"
  code={`{
  "name": "SolanaHelper",
  "clients": ["twitter", "discord"],
  "modelProvider": "openai",
  "plugins": ["@elizaos/plugin-solana"],
  "settings": {
    "secrets": {
      "SOLANA_PRIVATE_KEY": "your_base58_private_key",
      "SOLANA_RPC_URL": "your_rpc_url"
    }
  }
}`}
/>
**适合场景:** 需要跨平台保持持久身份的社交 agent。如果你要构建一个带有 Solana 能力的 Twitter 机器人或 Discord 助手,ElizaOS 是自然的选择。

### GOAT toolkit(Crossmint)

[GOAT](https://github.com/goat-sdk/goat)(Great Onchain Agent Toolkit)采取了不同的方法。它被设计为 AI agent 与任何区块链应用之间的通用适配器。Solana Agent Kit 专注于 Solana 特定操作,而 GOAT 提供跨 30 多条链(包括 Solana、EVM 网络等)的统一接口。

GOAT 的真正优势在于其集成广度。200 多个插件覆盖了从 Solana 上的 Jupiter、Orca 到 Ethereum 上的 [Uniswap](https://www.alchemy.com/dapps/uniswap) 和 [Aave](https://www.alchemy.com/dapps/aave) 等协议。如果你要构建需要跨多条链运作的 agent,GOAT 省去了针对每条链单独实现的必要。

初始化模式与 Solana Agent Kit 类似。首先初始化钱包,选择插件,然后为你的 AI 框架生成工具。下面是一个带 Jupiter 集成的 Solana 设置:

<CodeSnippet language="typescript" code={`import { getOnChainTools } from "@goat-sdk/adapter-vercel-ai";
import { solana } from "@goat-sdk/wallet-solana";
import { jupiter } from "@goat-sdk/plugin-jupiter";

const tools = await getOnChainTools({
wallet: solana({ keypair }),
plugins: [jupiter()]
});`} />
**适合场景:** 多链 agent 以及需要与特定 DeFi 协议集成的应用。GOAT 的插件生态在协议覆盖面上无出其右。

### Rig 框架(Rust)

对于性能要求严苛的应用——高频交易机器人、MEV 策略、低延迟敏感的操作,[Rig](https://rig.rs/) 提供了一个 Rust 原生的 AI agent 框架。结合用于 Solana 集成的 Listen.rs,它提供了从 LLM 决策到链上执行延迟最低的路径。

Rig 利用 Rust 的类型系统实现编译期正确性,并凭借其性能特性实现亚毫秒级操作。rig-onchain-kit 提供 Solana 集成,Listen.rs 则增加了交易监控以及用于 MEV 保护交易的 [Jito](https://www.alchemy.com/dapps/jito) bundle 提交功能。

API 简洁且符合 Rust 惯用风格。创建一个客户端,用系统提示词配置 agent,然后开始发送提示词:

<CodeSnippet language="rust" code={`use rig::{completion::Prompt, providers::openai};

#[tokio::main]
async fn main() {
let client = openai::Client::from_env();
let agent = client
.agent("gpt-4")
.preamble("You are a Solana trading assistant.")
.build();

    let response = agent.prompt("Analyze SOL/USDC market conditions").await?;

}`} />
**适合场景:** 延迟至关重要的性能关键型应用。如果你在构建交易基础设施,或需要与 Solana 原生 Rust 生态直接集成,Rig 是合适的选择。

### LangChain

[LangChain](https://github.com/langchain-ai/langchain) 是构建 LLM 驱动应用中采用最广泛的框架。虽然它并非专为区块链设计,但其工具抽象和 agent 架构使其天然适合 Solana 开发。Solana Agent Kit 提供了一流的 LangChain 集成,让你能够利用 LangChain 成熟的生态系统,同时访问 Solana 的链上能力。

LangChain 的优势在于可组合性,允许开发者将提示词、工具、记忆系统和检索机制串联成复杂的 agent 工作流。该框架处理对话管理、工具选择和输出解析。对于 Solana agent 来说,这意味着你可以将链上操作与链下数据源、RAG 管道和多步推理结合起来。

与 Solana Agent Kit 的集成是无缝的。你初始化 agent,然后使用 `createLangchainTools` 辅助函数,从你的 Solana 操作生成 LangChain 兼容的工具:

<CodeSnippet language="typescript" code={`import { SolanaAgentKit, createLangchainTools } from "solana-agent-kit";
import { ChatOpenAI } from "@langchain/openai";
import { createReactAgent } from "@langchain/langgraph/prebuilt";

const agent = new SolanaAgentKit(wallet, "YOUR_RPC_URL", {
OPENAI_API_KEY: "YOUR_OPENAI_API_KEY"
});

const tools = createLangchainTools(agent, agent.actions);

const llm = new ChatOpenAI({ model: "gpt-4o" });

const solanaAgent = createReactAgent({
llm,
tools
});

const result = await solanaAgent.invoke({
messages: [{ role: "user", content: "Check my SOL balance" }]
});`} />
当你需要将 Solana 操作与外部数据结合时,LangChain 同样大放异彩。你可以在区块链工具之外添加网络搜索工具、数据库检索器或自定义 API 集成。agent 会根据任务决定使用哪些工具。

**适合场景:** 已经在 LangChain 生态系统中工作的开发者,或需要将 Solana 操作与复杂推理链、RAG 或外部数据源结合的应用。如果你的 agent 需要的不仅仅是区块链交互,LangChain 提供了编排层。

## 构建你的第一个 Solana agent:分步指南

在覆盖了基础理论之后,我们来使用 Solana Agent Kit 和 LangChain 构建一个可用的 Solana AI agent。读完本节,你将拥有一个可以查询余额、执行兑换、并铸造财务收据 NFT 的 agent,全部通过自然语言指令完成。

我们会逐步构建,边讲解边推进。

### 前提条件

开始之前,请确保你具备以下条件:

- **Node.js v23 以上版本**:Solana Agent Kit 需要较新的 Node 特性。使用 `node --version` 检查你的版本。如果需要升级,nvm 可以让这一过程变得简单:

<CodeSnippet
  language="bash"
  code={`nvm install 23
nvm use 23`}
/>
- **一个 [Solana 钱包](https://www.alchemy.com/overviews/solana-wallets)**:你需要一个带有一些 devnet SOL 的密钥对用于测试。
如果你还没有,我们会帮你生成一个。- **API 密钥**:OpenAI(用于 LLM)
以及可选的专用 RPC 提供商,比如 Alchemy

### 项目设置

首先创建一个新目录并初始化你的项目:

<CodeSnippet
  language="bash"
  code={`mkdir solana-agent
cd solana-agent
pnpm init`}
/>
现在安装依赖。每个包都有特定用途:

<CodeSnippet
  language="bash"
  code={`pnpm add solana-agent-kit @langchain/core @langchain/openai @langchain/langgraph dotenv bs58`}
/>
每个依赖的作用如下:

- **solana-agent-kit**:提供 Solana 操作作为 LLM 兼容工具的核心工具包
- **@langchain/core**:消息、提示词和工具接口的基础抽象
- **@langchain/openai**:用于 LangChain 的 OpenAI 集成(GPT-4 作为我们的推理引擎)
- **@langchain/langgraph**:提供 ReAct agent 模式——即 LLM 推理应使用哪个工具、使用它、观察结果、再决定下一步行动的循环
- **dotenv**:从 `.env` 文件中加载环境变量
- **bs58**:用于 Solana 私钥的 Base58 编码/解码

### 环境配置

在项目根目录创建一个 `.env` 文件,这能让敏感凭据不出现在代码中:

<CodeSnippet
  language="bash"
  code={`OPENAI_API_KEY=your_openai_api_key
RPC_URL=https://api.devnet.solana.com
SOLANA_PRIVATE_KEY=[your,private,key,as,byte,array]`}
/>
关于私钥格式的说明:Solana 密钥对是 64 字节的数组。`.env`
文件将其存储为类似 `\[123,45,67,...\]` 的 JSON 数组。如果你需要
为测试生成一个新密钥对,可以使用:

<CodeSnippet language="bash" code={`solana-keygen grind --starts-with ai:1`} />
这会创建一个以"ai"开头的靓号地址(便于识别你的
agent 钱包)。输出结果包含密钥对的字节数组,你可以将其粘贴
到 `.env` 中。

**重要提示**:开发时切勿使用持有真实资金的密钥对。务必先在 devnet 上测试。

### 理解我们的 agent 架构

在写代码之前,先了解我们要构建的内容。我们的 agent 有三个主要组件:

1. **LLM(GPT-5.2)**:理解自然语言、推理应采取什么行动、并生成响应的"大脑"
1. **工具(Solana Agent Kit)**:LLM 可以调用的函数——查询余额、兑换代币、铸造 NFT 等
1. **Agent 循环([LangGraph ReAct](https://github.com/langchain-ai/react-agent))**:LangchainReAct 是使用 LangGraph 框架实现的 Reasoning and Acting(ReAct)agent 架构。这种编排模式连接了 LLM 和工具。当你发送一条消息时,agent 会接收你的输入 → 判断是否需要工具 → 调用工具 → 观察结果 → 判断是否需要更多工具 → 生成响应

这就是 ReAct(Reasoning + Acting)模式。LLM 并非仅仅做出响应,它会推理应采取什么行动,执行这些行动,并将结果纳入其响应中。

### Agent 脚本

现在让我们构建 `agent.ts`。我们会逐节讲解。

#### 导入和设置

<CodeSnippet language="typescript" code={`import { SolanaAgentKit, createSolanaTools } from "solana-agent-kit";
import { HumanMessage } from "@langchain/core/messages";
import { ChatOpenAI } from "@langchain/openai";
import { createReactAgent } from "@langchain/langgraph/prebuilt";
import { MemorySaver } from "@langchain/langgraph";
import * as dotenv from "dotenv";
import bs58 from "bs58";
import * as readline from "readline";

dotenv.config();`} />
这些导入可以分为三类:用于区块链操作的 Solana Agent Kit、用于 AI 编排的 LangChain,以及用于环境变量和用户输入的 Node 工具。

#### 初始化 agent

`initializeAgent` 函数负责设置所有组件:

<CodeSnippet
  language="typescript"
  code={`async function initializeAgent() {
  // Step 1: Initialize the LLM
  const llm = new ChatOpenAI({
    modelName: "gpt-4-turbo-preview",
    temperature: 0.7
  });`}
/>
我们使用 GPT-5.2 作为推理引擎。0.7 的 `temperature` 在
创造性与一致性之间取得平衡,较低的值让响应更具确定性,
较高的值则更多样化。对于需要在金融交易上做出可靠决策
的 agent,你可能希望将此值降到 0.3。

<CodeSnippet
  language="typescript"
  code={`// Step 2: Set up the Solana wallet
 const privateKeyArray = JSON.parse(process.env.SOLANA_PRIVATE_KEY!);
 const privateKeyUint8 = new Uint8Array(privateKeyArray);
 const privateKeyBase58 = bs58.encode(privateKeyUint8);`}
/>
这段代码将私钥从我们 `.env` 中的 JSON 数组格式
转换为 Solana Agent Kit 所需的 base58 字符串。转换路径为:JSON
字符串 → JavaScript 数组 → Uint8Array → base58 字符串。

<CodeSnippet
  language="typescript"
  code={`// Step 3: Initialize Solana Agent Kit
const solanaKit = new SolanaAgentKit(
  privateKeyBase58,
  process.env.RPC_URL!,
  { OPENAI_API_KEY: process.env.OPENAI_API_KEY! }
);`}
/>
`SolanaAgentKit` 实例将你的钱包连接到 Solana 网络。它
接受三个参数:私钥(用于签名交易)、RPC URL
(用于网络通信),以及配置选项(包括用于任何内部 AI 操作
的 OpenAI 密钥)。

<CodeSnippet
  language="typescript"
  code={`// Step 4: Create tools from the kit
 const tools = createSolanaTools(solanaKit);`}
/>
奇妙之处就在这里。`createSolanaTools` 将 Solana Agent
Kit 的能力转换为 LangChain 兼容的工具。每个工具都有名称、
描述和输入 schema,供 LLM 理解自己能做什么以及
如何调用。在底层,你得到的工具包括 `get\_balance`、
`transfer`、`swap`、`deploy\_token`、`mint\_nft`,以及更多。

<CodeSnippet
  language="typescript"
  code={`// Step 5: Set up memory for conversation context
const memory = new MemorySaver();`}
/>
记忆功能让 agent 能够跨多轮对话维持上下文。没有它,
每条消息都会被孤立处理,agent 不会记得你刚才
询问了余额,然后你紧接着说"把其中一半兑换掉"。

<CodeSnippet
  language="typescript"
  code={`  // Step 6: Create the ReAct agent
  return createReactAgent({
    llm,
    tools,
    checkpointSaver: memory
  });
}`}
/>
最后,我们将所有部分组装成一个 ReAct agent。这创建了推理
循环:LLM 接收输入,决定使用哪个工具(如果需要),执行它,
观察结果,然后要么采取另一个行动,要么向用户响应。

#### 交互式聊天循环

第二个函数创建了一个与 agent 对话的终端界面:

<CodeSnippet
  language="typescript"
  code={`async function runInteractiveChat() {
  const agent = await initializeAgent();
  const config = { configurable: { thread_id: "solana-agent-session" } };`}
/>
`thread\_id` 用于记忆目的,标识这次对话。如果你
用相同的线程 ID 重启脚本,agent 理论上会
记得之前的上下文。不同的线程 ID 代表不同的对话
上下文。

<CodeSnippet language="typescript" code={`const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

console.log("Solana AI Agent Ready (type 'exit' to quit)");
console.log("--------------------------------------------");`} />
标准的 Node.js readline 设置,用于终端输入/输出,创建一个 readline 接口来捕获你从终端的键盘输入(`stdin`),并将 agent 的响应写回你的屏幕(`stdout`)。这是构建交互式命令行聊天的最简单方式,无需引入额外依赖。

<CodeSnippet language="typescript" code={`const askQuestion = () => {
  rl.question("You: ", async (input) => {
    if (input.toLowerCase() === "exit") {
      rl.close();
      return;
    }

    const stream = await agent.stream(
      { messages: [new HumanMessage(input)] },
      config
    );`} />

当你输入一条消息时,它会被包装成一个 `HumanMessage` 并发送给 agent。我们使用 `stream` 而不是 `invoke`,从而在 agent 思考和行动的过程中获得实时输出。

<CodeSnippet language="typescript" code={`      process.stdout.write("Agent: ");
      for await (const chunk of stream) {
        if ("agent" in chunk) {
          process.stdout.write(chunk.agent.messages[0].content);
        } else if ("tools" in chunk) {
          process.stdout.write(chunk.tools.messages[0].content);
        }
      }
      console.log("\\n--------------------------------------------");
      askQuestion();
    });
  };

askQuestion();
}

runInteractiveChat().catch(console.error);`} />
流式循环处理两类数据块:`agent` 数据块(LLM 的推理和响应)和 `tools` 数据块(工具执行的结果)。这让你可以实时看到正在发生的一切——agent 思考、调用工具、组织响应。

### 完整脚本

以下是完整的 `agent.ts` 以供参考:

<CodeSnippet language="typescript" code={`import { SolanaAgentKit, createSolanaTools } from "solana-agent-kit";
import { HumanMessage } from "@langchain/core/messages";
import { ChatOpenAI } from "@langchain/openai";
import { createReactAgent } from "@langchain/langgraph/prebuilt";
import { MemorySaver } from "@langchain/langgraph";
import * as dotenv from "dotenv";
import bs58 from "bs58";
import * as readline from "readline";

dotenv.config();

async function initializeAgent() {
const llm = new ChatOpenAI({
modelName: "gpt-5.2,
temperature: 0.7
});

const privateKeyArray = JSON.parse(process.env.SOLANA_PRIVATE_KEY!);
const privateKeyUint8 = new Uint8Array(privateKeyArray);
const privateKeyBase58 = bs58.encode(privateKeyUint8);

const solanaKit = new SolanaAgentKit(
privateKeyBase58,
process.env.RPC_URL!,
{ OPENAI_API_KEY: process.env.OPENAI_API_KEY! }
);

const tools = createSolanaTools(solanaKit);
const memory = new MemorySaver();

return createReactAgent({
llm,
tools,
checkpointSaver: memory
});
}

async function runInteractiveChat() {
const agent = await initializeAgent();
const config = { configurable: { thread_id: "solana-agent-session" } };

const rl = readline.createInterface({
input: process.stdin,
output: process.stdout
});

console.log("Solana AI Agent Ready (type 'exit' to quit)");
console.log("--------------------------------------------");

const askQuestion = () => {
rl.question("You: ", async (input) => {
if (input.toLowerCase() === "exit") {
rl.close();
return;
}

      const stream = await agent.stream(
        { messages: [new HumanMessage(input)] },
        config
      );

      process.stdout.write("Agent: ");
      for await (const chunk of stream) {
        if ("agent" in chunk) {
          process.stdout.write(chunk.agent.messages[0].content);
        } else if ("tools" in chunk) {
          process.stdout.write(chunk.tools.messages[0].content);
        }
      }
      console.log("\\n--------------------------------------------");
      askQuestion();
    });

};

askQuestion();
}

runInteractiveChat().catch(console.error);`} />

### 运行 agent

使用 tsx(TypeScript 执行工具)运行:

<CodeSnippet language="bash" code={`npx tsx agent.ts`} />
你应该能看到就绪消息。现在试试一些命令:

<CodeSnippet code={`You: What's my wallet address and SOL balance?
Agent: Your wallet address is Ai7f...x3K2. Current balance is 1.5 SOL.

You: Swap 0.1 SOL for USDC
Agent: I'll execute a swap of 0.1 SOL for USDC using Jupiter...
Transaction confirmed: https://solscan.io/tx/...

You: Create an NFT collection called "AI Agents" with symbol "AIA"
Agent: Creating NFT collection with Metaplex...
Collection created: https://solscan.io/token/...`} />
底层发生的事情是:当你询问余额时,LLM 识别出这需要
`get\_balance` 工具,用正确的参数调用它,接收结果,
并将其整合为自然语言响应。对于兑换操作,它识别出
`swap` 工具,解析你的意图(0.1 SOL → USDC),
执行 Jupiter 兑换,并确认交易。

### 你已构建完成的内容

你现在拥有了一个可运行的 Solana AI agent,具备:

- 通过 GPT-5.2 实现自然语言理解
- 60 多个作为工具可用的 Solana 操作
- 支持多轮交互的对话记忆
- 实时流式响应

这是一个开发基础。生产部署需要考虑更多因素,包括钱包安全、交易可靠性、速率限制,我们将在后续章节中介绍。

## 为 DeFi 操作集成 Jupiter

Jupiter 是 Solana 占主导地位的 DEX 聚合器,处理超过 90% 的聚合器交易量。当你的 agent 需要兑换代币时,Jupiter 会在几十个 DEX(Raydium、Orca、Phoenix 等)之间寻找最佳路由,以获得最优定价。

Solana Agent Kit 内置了开箱即用的 Jupiter 集成。当你让 agent "把 1 个 SOL 兑换成 USDC"时,它底层已经在使用 Jupiter。但有时你需要更多的控制权:自定义滑点容差、特定的路由偏好,或与你自己的交易管道直接集成。

### Jupiter 的工作原理

Jupiter 的 API 遵循先报价后兑换的模式:

1. **报价**:你发送输入代币、输出代币和数量。Jupiter 查询所有可用的 DEX,并返回带有预期输出数量的最佳路由。
1. **兑换**:你将报价连同你的钱包地址一起发回。Jupiter 构造一笔执行最优路由的交易。
1. **签名并提交**:你对交易进行签名,并将其提交到网络。

这个两步流程让你能够在用户提交交易之前,先向他们展示将收到的结果。

### 直接集成 Jupiter

下面是一个完整的兑换函数,带有逐步说明:

<CodeSnippet language="typescript" code={`import { Connection, Keypair, VersionedTransaction } from "@solana/web3.js";
import { createJupiterApiClient } from "@jup-ag/api";

// Token mint addresses (mainnet)
const USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
const SOL_MINT = "So11111111111111111111111111111111111111112";`} />
我们从标准的 Solana web3.js 导入和 Jupiter API 客户端开始。mint 地址是 Solana 上代币的唯一标识符。SOL 使用一个特殊的"wrapped"地址以兼容 DEX。

<CodeSnippet
  language="typescript"
  code={`async function executeSwap(
  connection: Connection,
  wallet: Keypair,
  inputMint: string,
  outputMint: string,
  amount: number  // in smallest units (lamports for SOL, 6 decimals for USDC)
) {
  const jupiter = createJupiterApiClient();`}
/>
Jupiter 客户端连接到他们托管的 API。基本用法
无需 API 密钥,不过会有速率限制。

<CodeSnippet
  language="typescript"
  code={`// Step 1: Get a quote
const quote = await jupiter.quoteGet({
  inputMint,
  outputMint,
  amount,
  slippageBps: 50  // 0.5% slippage tolerance
});`}
/>
报价请求指定了你要交易的内容。`slippageBps` 是以
基点表示的滑点容差,50 表示 0.5%。如果在报价和执行
之间价格变动超过这个幅度,交易会失败,而不是
以更差的价格执行。

报价响应包含预期的输出数量、路由(将使用哪些 DEX)以及价格影响。对于生产环境的 agent,你应该在继续执行前检查这些值。

<CodeSnippet
  language="typescript"
  code={`// Step 2: Get the swap transaction
const { swapTransaction } = await jupiter.swapPost({
  swapRequest: {
    quoteResponse: quote,
    userPublicKey: wallet.publicKey.toString(),
    wrapAndUnwrapSol: true  // Automatically handle SOL wrapping
  }
});`}
/>
兑换请求接受你的报价和钱包地址,并返回一笔序列化
交易。`wrapAndUnwrapSol: true` 处理了 Solana 的一个特殊之处:
DEX 使用的是"wrapped SOL"(一种 SPL 代币),但用户持有的是
原生 SOL。该标志会自动添加在兑换前后分别用于
wrap 和 unwrap 的指令。

<CodeSnippet
  language="typescript"
  code={`// Step 3: Deserialize and sign
const transaction = VersionedTransaction.deserialize(
  Buffer.from(swapTransaction, "base64")
);
transaction.sign([wallet]);`}
/>
Jupiter 以 base64 编码字符串的形式返回交易。我们将其反序列化
为正式的交易对象,并用我们的密钥对对其签名。请注意我们使用的是
`VersionedTransaction,`——Jupiter 使用的是 Solana 较新的交易格式,
支持地址查找表以处理更复杂的路由。

<CodeSnippet language="typescript" code={`  // Step 4: Submit and confirm
  const signature = await connection.sendTransaction(transaction);
  await connection.confirmTransaction(signature);

return signature;
}`} />
最后,我们将签名后的交易提交到网络并等待确认。签名是一个唯一标识符,你可以用它在 [Solscan](https://www.alchemy.com/dapps/solscan) 等浏览器上查询该交易。

### Jupiter MCP 服务器

对于支持 Model Context Protocol 的 AI 助手(如 Claude Desktop 或 Cursor),Jupiter 提供了一个 MCP 服务器。这让你的 AI 助手能够通过标准化接口直接访问 Jupiter 的能力。

在你的 MCP 设置中进行如下配置:

<CodeSnippet
  language="json"
  code={`{
  "mcpServers": {
    "jupiter": {
      "command": "npx",
      "args": ["jupiter-ultra-mcp"],
      "env": {
        "RPC_URL": "your_rpc_url",
        "PRIVATE_KEY": "your_private_key"
      }
    }
  }
}`}
/>
配置完成后,Claude 就可以直接通过自然语言
执行 Jupiter 兑换:"把 0.5 SOL 兑换成 USDC"会变成一笔
真实的链上交易。这对快速原型开发尤其有效:你可以
先通过对话构建并测试 DeFi 工作流,之后再投入编码。

## 钱包安全架构

拥有签名权限的 AI agent 是一个高价值目标。一个被攻破的 agent 可以瞬间把钱包清空。安全架构必须在自主性和保护之间取得平衡。

### 双密钥架构

安全 agent 钱包的新兴标准是采用双密钥架构配合智能合约钱包:

**智能合约钱包:** 一个可以拥有多个授权签名者的钱包(在 EVM 上使用 ERC-4337 模式,或在 Solana 上使用 Squads 协议)。

**所有者密钥:** 由用户持有,提供最终控制权。有了它,你可以添加/移除 agent 密钥、提取资金,并覆盖 agent 的操作。

**Agent 密钥:** 部署在可信执行环境(TEE)内,以有限权限注册到智能钱包。凭借此密钥,agent 只能执行授权的操作。

Crossmint 的实现让这一切变得简单直接。你创建一个与用户身份绑定的托管钱包,agent 则在你定义的权限范围内运作:

<CodeSnippet language="typescript" code={`import { crossmint } from "@goat-sdk/crossmint";
import { Connection } from "@solana/web3.js";

const { custodial } = crossmint(apiKey);

const wallet = await custodial({
chain: "solana",
email: userEmail,
connection: new Connection(rpcUrl, "confirmed")
});

// Agent receives limited permissions through the smart wallet
// Owner retains full control`} />

### TEE 保护

可信执行环境为 agent 密钥提供硬件级别的隔离。像 Phala Network 和 Turnkey 这样的平台提供专为 AI agent 设计的 TEE 基础设施。

Turnkey 提供策略控制的钱包访问。agent 不会暴露私钥,而是获得受限范围的 API 凭据,只能执行授权的操作。你可以定义策略来限制交易类型、金额和速率——agent 则在这些防护边界内运作:

<CodeSnippet language="typescript" code={`\`import { Turnkey } from "@turnkey/sdk-server";
import { TurnkeySigner } from "@turnkey/solana";

const turnkey = new Turnkey({
apiBaseUrl: "https://api.turnkey.com",
apiPrivateKey: process.env.TURNKEY_API_PRIVATE_KEY,
apiPublicKey: process.env.TURNKEY_API_PUBLIC_KEY,
defaultOrganizationId: process.env.TURNKEY_ORGANIZATION_ID
});

const signer = new TurnkeySigner({
organizationId: process.env.TURNKEY_ORGANIZATION_ID,
client: turnkey.api
});

// Policies limit what the agent can do:
// - Only token transfers (no other transaction types)
// - Maximum transaction size
// - Rate limits\``} />
Phala Network 提供去中心化的 TEE 基础设施。部署到 Phala 的 agent 运行在隔离的 enclave 中,即使宿主系统也无法访问私钥。部署方式基于容器:

<CodeSnippet language="bash" code={`# Build agent for TEE deployment
docker build --platform linux/amd64 -t agent:latest .

# Deploy to phala cloud

phala deploy agent:latest --api-key $PHALA_API_KEY`} />

### 安全最佳实践

以下几项原则应指导 agent 安全架构的设计:

- **最小化密钥暴露:** 私钥绝不应出现在日志、错误消息或可被访问的内存中。使用环境变量和安全的密钥管理基础设施。
- **实施交易限制:** Agent 应有最大交易规模、每日支出上限和速率限制。一个被攻破且拥有无限权限的 agent 可以造成无限损失。
- **使用独立钱包:** 生产环境中的 agent 应使用仅持有运作所需资金的专用钱包。切勿将 agent 连接到持有大量资产的钱包。
- **监控 agent 活动:** 记录所有 agent 交易,并针对异常模式实施告警。自动化监控能在造成重大损失之前发现问题。
- **先在 devnet 测试:** 在部署到主网之前,务必先在 devnet 上开发和测试 agent。通常只需更改 RPC URL 即可切换网络。

## Model Context Protocol(MCP)集成

Model Context Protocol 标准化了 AI 助手与外部工具交互的方式。对于 Solana 开发,MCP 服务器让 Claude、Cursor 及其他 AI 工具能直接与区块链交互。

### Solana MCP 服务器

来自 SendAI 的 [Solana MCP 服务器](https://mcp.solana.com/)为任何兼容 MCP 的 AI 助手提供区块链工具:

<CodeSnippet language="bash" code={`# Install globally
npm install -g solana-mcp

# Or run directly

npx solana-mcp`} />
MCP 服务器中可用的工具包括:

- `GET\_ASSET`:检索代币/NFT 信息
- `GET\_BALANCE`:查询钱包余额
- `TRANSFER`:发送 SOL 或 SPL 代币
- `SWAP`:执行 Jupiter 兑换
- `DEPLOY\_TOKEN`:创建新的 SPL 代币
- `MINT\_NFT`:通过 Metaplex 铸造 NFT

## 使用 ElizaOS 构建:Twitter 机器人示例

到目前为止,我们构建了一个可以推理、执行 Solana 交易、并维持对话上下文的可用 agent,全部都在终端中完成。现在让我们把这些相同的能力部署到用户实际活动的地方:Twitter,使用 ElizaOS。

ElizaOS 在社交 agent 方面表现出色,这类机器人能在不同平台上保持持久的人格。让我们来构建一个 Twitter 机器人。

### 我们要构建的内容

这个机器人将会:

- 监控 Twitter 上询问代币、协议或市场状况的提及
- 获取链上数据:代币价格、交易量、流动性深度、巨鲸动向
- 用通俗易懂的语言分析和总结数据
- 在所有交互中保持一致的"分析师"人格

ElizaOS 负责处理复杂的编排工作:监听提及、维持对话上下文、决定何时查询链上数据,以及生成符合所定义人格的响应。

### 理解 ElizaOS 架构

在深入代码之前,我们先了解 ElizaOS 是如何构建一个 agent 的:

**客户端(Clients)**将 agent 连接到各个平台:Twitter、Discord、Telegram 或直接 API 访问。每个客户端处理平台特定的身份验证、消息轮询和响应格式化。

**插件(Plugins)**提供能力。Solana 插件为你的 agent 提供读取链上数据、代币查询和交易历史的工具。其他插件可能增加图像生成、网络搜索或自定义操作。

**角色文件(Character files)**通过结构化的 JSON 定义人格和行为。这包括简介、沟通风格、示例对话和行为参数。

**记忆(Memory)**在对话间持续保留。ElizaOS 会跟踪 agent 与谁交谈过、对方问过哪些问题,以及对未来交互有用的相关上下文。

### 设置

首先克隆 ElizaOS 代码仓库:

<CodeSnippet
  language="bash"
  code={`git clone https://github.com/elizaOS/eliza.git
cd eliza`}
/>
ElizaOS 是一个 monorepo,包含核心框架、所有官方插件,以及
客户端实现。我们会在这个结构内工作,而不是创建一个
单独的项目。

安装依赖并构建:

<CodeSnippet
  language="bash"
  code={`pnpm install --no-frozen-lockfile
pnpm build`}
/>
`--no-frozen-lockfile` 标志允许 pnpm 在需要时更新 lockfile。
构建步骤会编译 TypeScript 并准备好所有的包。

### 环境配置

在项目根目录创建一个 `.env` 文件。ElizaOS 会从这里读取所有凭据和配置:

<CodeSnippet
  language="bash"
  code={`# Twitter credentials
TWITTER_USERNAME=your_bot_username
TWITTER_PASSWORD=your_password
TWITTER_EMAIL=your_email`}
/>
Twitter 身份验证使用你机器人账户的凭据。ElizaOS 会登录并
维持一个会话,用于轮询提及和发布回复。请确保使用
专门的机器人账户——你不希望自己的个人 Twitter 运行着一个
自动化 agent。

<CodeSnippet
  language="bash"
  code={`# LLM provider
OPENAI_API_KEY=your_openai_key`}
/>
模型提供商为 agent 的推理提供支持。ElizaOS 支持多个
提供商(OpenAI、Anthropic、本地模型),但 OpenAI 是最
容易上手的。

<CodeSnippet
  language="bash"
  code={`# Solana configuration
SOLANA_RPC_URL=https://solana-mainnet.g.alchemy.com/v2/your-api-key
SOLANA_PUBLIC_KEY=your_public_key
SOLANA_CLUSTER=mainnet-beta`}
/>
对于一个分析师机器人,你不需要私钥——我们是在读取数据,而不是签名
交易。使用主网 RPC,因为你想要的是真实市场数据,而不是 devnet 测试
代币。像 Alchemy 这样的专用 RPC 提供商能给你比公共端点
更高的速率限制和更可靠的数据。

**安全提示**:即使这个机器人只读取数据,也要保护好你的 API 密钥。你的 RPC 提供商的速率限制与这些凭据绑定。

### 理解角色文件

角色文件是 ElizaOS agent 的核心。它们不仅定义了 agent 能做什么,还定义了它是谁。让我们一块块地构建一个。

创建 `characters/solana-analyst.character.json`:

<CodeSnippet
  language="json"
  code={`{
  "name": "SolanaAnalyst",
  "clients": ["twitter"],
  "modelProvider": "openai",
  "plugins": ["@elizaos/plugin-solana"],`}
/>
头部定义了基本信息:

- **name**:agent 如何自我标识
- **clients**:连接到哪些平台。在这里添加 `"discord"` 即可启用 Discord 集成,无需额外代码。
- **modelProvider**:使用哪个 LLM 进行推理
- **plugins**:要启用的能力。Solana 插件提供代币数据查询、价格 feed 和链上分析。

<CodeSnippet
  language="json"
  code={`"bio": [
  "On-chain analyst tracking Solana markets in real-time.",
  "I dig through blockchain data so you don't have to. Ask me about any token, protocol, or wallet.",
  "Turning raw on-chain data into actionable insights."
],`}
/>
`bio` 是一个定义 agent 自我描述的语句数组。
ElizaOS 会在 agent 需要自我介绍或回答"你是谁?"
这类问题时使用这些语句。多条记录能增加多样性——agent 可能在
不同语境下引用不同的简介语句。

<CodeSnippet
  language="json"
  code={`"lore": [
   "Built to democratize access to on-chain intelligence.",
   "Processes thousands of transactions to surface what matters.",
   "No alpha is safe from on-chain analysis."
 ],`}
/>
`lore` 提供了 agent 可以参考的背景信息。这不会直接
展示给用户,但会影响 agent 如何理解自身的目的
和历史。可以把它看作 agent 内部的背景故事。

<CodeSnippet
  language="json"
  code={`"messageExamples": [
  [
    {"user": "user1", "content": {"text": "What's happening with SOL today?"}},
    {"user": "SolanaAnalyst", "content": {"text": "SOL is trading at $142.50, up 3.2% in the last 24h. Volume is elevated at $2.1B—about 40% above the 7-day average. The bid-ask spread on Jupiter is tight at 0.02%, suggesting healthy liquidity. No unusual whale movements in the past hour."}}
  ],
  [
    {"user": "user1", "content": {"text": "Any big wallets moving JUP?"}},
    {"user": "SolanaAnalyst", "content": {"text": "Spotted two notable JUP movements in the last 6 hours: a 2.3M JUP transfer from a known market maker wallet to Binance (possible sell pressure incoming), and 890K JUP moved from the team vesting contract to a new wallet. The Binance deposit is worth watching—historically these precede increased selling within 24-48 hours."}}
  ],
  [
    {"user": "user1", "content": {"text": "Is Marinade still the top liquid staking protocol?"}},
    {"user": "SolanaAnalyst", "content": {"text": "Marinade holds $1.2B in TVL, but Jito has been gaining ground fast—now at $980M, up 15% this month. The gap is closing. Marinade's mSOL still has deeper DEX liquidity, but jitoSOL is seeing better integration with newer DeFi protocols. If you're optimizing for composability, Jito might edge ahead soon."}}
  ]
],`}
/>
`messageExamples` 是教 agent 如何响应的少样本示例。
每个示例都是一个展示用户输入和预期 agent
响应的对话数组。注意这些示例是如何确立基调的:数据驱动、具体的
数字、可操作的上下文、没有废话。

添加更多示例以覆盖边缘情况:如果有人问一个不存在的代币怎么办?如果他们想要对比分析怎么办?如果他们在问一个骗局代币怎么办?覆盖的场景越多,agent 的行为就越一致。

<CodeSnippet
  language="json"
  code={`  "style": {
    "all": ["data-driven", "concise", "insightful", "avoids hype"],
    "chat": ["direct", "analytical", "provides context for numbers"],
    "post": ["informative", "highlights unusual activity", "actionable"]
  }
}`}
/>
`style` 定义了不同语境下的沟通模式:

- `all`:适用于每个响应
- `chat`:特定于私信和回复
- `post`:用于 agent 创建的原创帖子

这些是影响 LLM 语气的描述性关键词。"avoids hype"(避免炒作)对金融分析师来说很重要——你想要的是审慎的分析,而不是"SOL TO THE MOON 🚀"。"provides context for numbers"(为数字提供上下文)确保 agent 不会只是甩出一串价格,而是解释这些数字意味着什么。

### 完整的角色文件

以下是完整的角色定义:

<CodeSnippet
  language="json"
  code={`{
  "name": "SolanaAnalyst",
  "clients": ["twitter"],
  "modelProvider": "openai",
  "plugins": ["@elizaos/plugin-solana"],
  "bio": [
    "On-chain analyst tracking Solana markets in real-time.",
    "I dig through blockchain data so you don't have to. Ask me about any token, protocol, or wallet.",
    "Turning raw on-chain data into actionable insights."
  ],
  "lore": [
    "Built to democratize access to on-chain intelligence.",
    "Processes thousands of transactions to surface what matters.",
    "No alpha is safe from on-chain analysis."
  ],
  "messageExamples": [
    [
      {"user": "user1", "content": {"text": "What's happening with SOL today?"}},
      {"user": "SolanaAnalyst", "content": {"text": "SOL is trading at $142.50, up 3.2% in the last 24h. Volume is elevated at $2.1B—about 40% above the 7-day average. The bid-ask spread on Jupiter is tight at 0.02%, suggesting healthy liquidity. No unusual whale movements in the past hour."}}
    ],
    [
      {"user": "user1", "content": {"text": "Any big wallets moving JUP?"}},
      {"user": "SolanaAnalyst", "content": {"text": "Spotted two notable JUP movements in the last 6 hours: a 2.3M JUP transfer from a known market maker wallet to Binance (possible sell pressure incoming), and 890K JUP moved from the team vesting contract to a new wallet. The Binance deposit is worth watching—historically these precede increased selling within 24-48 hours."}}
    ],
    [
      {"user": "user1", "content": {"text": "Is Marinade still the top liquid staking protocol?"}},
      {"user": "SolanaAnalyst", "content": {"text": "Marinade holds $1.2B in TVL, but Jito has been gaining ground fast—now at $980M, up 15% this month. The gap is closing. Marinade's mSOL still has deeper DEX liquidity, but jitoSOL is seeing better integration with newer DeFi protocols. If you're optimizing for composability, Jito might edge ahead soon."}}
    ]
  ],
  "style": {
    "all": ["data-driven", "concise", "insightful", "avoids hype"],
    "chat": ["direct", "analytical", "provides context for numbers"],
    "post": ["informative", "highlights unusual activity", "actionable"]
  }
}`}
/>
### 启动你的 agent

用你的角色文件启动 agent:

<CodeSnippet
  language="bash"
  code={`pnpm start --character="characters/solana-analyst.character.json"`}
/>
你会看到 ElizaOS 的日志输出:

1. 加载角色定义
1. 初始化 OpenAI 提供商
1. 连接到 Twitter
1. 加载 Solana 插件
1. 开始轮询提及

### 当有人发推文时会发生什么

当用户发推文"@YourBot BONK 今天的交易量是多少?"时,流程如下:

1. **Twitter 客户端**通过轮询检测到这条提及
1. **消息处理器**解析推文并创建对话上下文
1. **LLM** 接收这条消息,连同角色定义、简介和示例一起
1. **工具选择**识别出这是一个数据查询,并选择相应的 Solana 插件操作
1. **插件执行**从 RPC 获取代币数据,并从 Jupiter 聚合价格
1. **响应生成**创建一条为原始数据提供上下文的回复
1. **Twitter 客户端**将回复作为一条串发布

agent 会维持这次交互的记忆。如果同一用户一小时后问"那和昨天比怎么样?",agent 可以引用之前的对话并提供对比分析。

### 扩展机器人

角色文件这种方式让迭代变得很快。想要添加 Discord 支持?

<CodeSnippet language="json" code={`"clients": ["twitter", "discord"]`} />
为 Discord 添加环境变量,重启,你的 agent 现在就能以
相同的人格同时运行在两个平台上。

想要添加主动提醒?你可以配置 agent 在检测到异常活动时发帖:

<CodeSnippet
  language="json"
  code={`"settings": {
  "autoPost": true,
  "postInterval": 3600,
  "postTopics": ["whale movements", "unusual volume", "TVL changes"]
}`}
/>
现在 agent 会独立监控链上活动,并在发现值得关注的事情时
发推——无需用户提示。

### 社交机器人的生产环境考量

Twitter 有速率限制和自动化政策。对于生产部署:

- **速率限制**:不要对每个提及都立即响应。添加模拟人类响应时间的延迟。
- **内容政策**:Twitter 的自动化规则要求明确披露该账户是机器人。把这个信息放在简介中。
- **数据准确性**:你的机器人在提供金融信息。添加免责声明、注明数据来源、并明确说明局限性。"非财务建议"不只是法律保护——这是负责任的做法。
- **错误处理**:RPC 调用可能失败,数据可能过时,代币可能被下架。妥善处理这些情况,而不是公开发布错误信息。
- **监控**:跟踪机器人处理的查询以及生成的响应。你需要了解它在说什么,尤其是在市场波动剧烈的时候。

## Agent 工具:CLI、Skills 和 MCP

框架负责编排。[面向 agent 的 Alchemy](https://www.alchemy.com/agents)覆盖了基础设施层。

安装 [Alchemy Skills](https://www.alchemy.com/docs/alchemy-agent-skills)、连接 [MCP 服务器](https://www.alchemy.com/docs/alchemy-mcp-server)、并验证 [CLI](https://www.alchemy.com/docs/alchemy-cli):

<CodeSnippet
  language="bash"
  code={`npx skills add alchemyplatform/skills --yes

# Claude Code
claude mcp add alchemy --transport http https://mcp.alchemy.com/mcp

# Codex
codex mcp add alchemy --url https://mcp.alchemy.com/mcp

npm i -g @alchemy/cli@latest
alchemy auth`}
/>

从终端进行查询:

<CodeSnippet
  language="bash"
  code={`alchemy --json --no-interactive solana rpc getSlot -n solana-mainnet
alchemy --json --no-interactive prices symbol SOL,ETH
alchemy --json --no-interactive agent-prompt`}
/>

## 结语

你现在已经构建了你的第一个 Solana AI agent。如果本教程有一个要点需要你记住,那就是在 Solana 上构建 AI agent 的基础设施已经取得了巨大的成熟进展。

这条链足够快。框架已经准备就绪。问题在于你将用它们构建什么。

准备好开始了吗?[Alchemy](https://alchemy.com/) 提供支撑 Solana 上领先 AI agent 和框架的 RPC 基础设施。无论你需要低延迟端点、用于代币操作的增强型 API,还是支持跨平台 agent 的多链能力,Alchemy 的平台都能为你提供构建能够大规模运作的生产级 AI agent 所需的基础。

## 常见问题

### 在构建 Solana AI agent 时,你们推荐使用哪些工具?

我们建议根据你的使用场景选择 Solana Agent Kit、ElizaOS、GOAT toolkit 和 Rig 框架。Solana Agent Kit 提供 60 多个预构建操作,适合快速原型开发;ElizaOS 在跨平台社交 agent 方面表现出色;GOAT 提供多链支持;Rig 则提供性能关键型的 Rust 原生开发。

### 为什么 Solana 更适合 AI agent 开发?

Solana 400 毫秒的出块时间和亚秒级的最终确认速度支持实时反馈循环,让 agent 能够快速地推理、行动并观察结果。交易费用平均为 0.00025 美元,使高频操作在经济上可行,而原生程序可组合性让 agent 能在单笔原子交易中执行复杂的多步操作。

### 构建 Solana AI agent 最适合使用哪些编程语言?

TypeScript 配合 Solana Agent Kit 或 LangChain 非常适合快速开发和广泛的生态系统集成。对于高频交易或 MEV 策略这样对性能要求严苛的应用,使用 Rig 框架的 Rust 提供了从 LLM 决策到链上执行延迟最低的路径。

### 我应该如何保护我的 AI agent 钱包?

使用带有智能合约钱包的双密钥架构,所有者密钥提供最终控制权,agent 密钥则在具有有限权限的可信执行环境(TEE)中运作。切勿在日志中暴露私钥,实施交易限制,使用资金最少的独立钱包,并务必先在 devnet 上测试。

### 我能构建一个运行在 Twitter 或 Discord 上的 AI agent 吗?

可以,ElizaOS 让 agent 能够同时在 Twitter、Discord、Telegram 及其他平台上维持持久的人格。你通过一个角色 JSON 文件来定义 agent 的行为,ElizaOS 负责处理平台特定的身份验证、消息轮询和响应格式化。

### 我该如何在我的 agent 中集成 Jupiter 来实现代币兑换?

Solana Agent Kit 通过预构建的兑换操作内置了开箱即用的 Jupiter 集成。对于自定义实现,可以使用 Jupiter 先报价后兑换的 API 模式:用你的交易对请求报价,用你的钱包地址构造兑换交易,然后签名并提交这笔版本化交易。

### 什么是 Model Context Protocol(MCP),它有什么用处?

MCP 标准化了 AI 助手与外部工具交互的方式。Solana MCP 服务器让 Claude、Cursor 及其他兼容 MCP 的 AI 工具能够通过自然语言直接执行区块链操作,包括查询余额、代币转账、兑换和 NFT 铸造。

### 构建 Solana AI agent 时常见的错误有哪些?

AI 生成的代码可能会产生顺序的账户更新,而不是并行处理,或者忽略 Solana 特有的优化。务必审查生成的代码是否在计算单元效率、使用 Program Derived Address(PDA)等安全最佳实践,以及针对 RPC 调用和交易失败的恰当错误处理方面做得到位。