Como criar agentes de IA Solana em 2026

Última atualização: 26 de janeiro de 202622 min de leitura

Linha de rostos de agentes de IA ilustrando o desenvolvimento de agentes de IA na Solana

Agentes de IA estão transformando a forma como interagimos com a infraestrutura blockchain. Esses programas autônomos podem executar transações, gerenciar portfólios, mintar NFTs e interagir com protocolos DeFi, tudo através de comandos em linguagem natural. Um contraste e tanto com a UX dos primórdios do crypto.

Solana se tornou a blockchain líder para desenvolvimento de agentes de IA, respondendo por 77% do volume de transações x402 em dezembro de 2025, combinando finalidade em menos de um segundo, custos de transação insignificantes e um ecossistema maduro de frameworks construídos especificamente para aplicações agênticas.

Este guia percorre a construção de agentes de IA prontos para produção na Solana, desde a escolha do framework certo até a implementação de arquiteturas de wallet seguras. Seja você construindo um bot de trading, um assistente onchain pessoal ou um gerenciador de DeFi autônomo, você encontrará aqui a base técnica necessária.

Por que Solana para agentes de IA?

Agentes de IA têm o potencial de transformar a atividade onchain e desbloquear casos de uso inteiramente novos, o que leva a uma pergunta importante para desenvolvedores que querem começar: em qual blockchain construir agentes de IA?

A resposta, cada vez mais, é Solana. Um único agente monitorando mercados, executando trades e rebalanceando portfólios pode enviar centenas de transações por dia. Na Ethereum mainnet, esse ritmo operacional poderia custar milhares de dólares em gas. Na Solana, custa centavos. Mas o custo é só o ponto de partida; a arquitetura da Solana se alinha com os requisitos dos agentes de formas que vão muito além das taxas:

Velocidade importa para autonomia: Agentes precisam reagir a condições de mercado, solicitações de usuários e eventos onchain em tempo real. Os blocos de 400ms e a finalidade em menos de um segundo da Solana permitem loops de feedback rápidos. Agentes operam em ciclos: raciocinam sobre o que fazer, executam uma ação, observam o resultado e raciocinam novamente. Cada etapa de "observação" exige esperar a confirmação da transação. Em uma chain com blocos de 12 segundos, um fluxo de 3 etapas significa 36+ segundos de espera ociosa entre decisões, o agente perde o loop de feedback rápido que faz a operação autônoma parecer responsiva. Na Solana, esse mesmo fluxo confirma em menos de 2 segundos, permitindo que agentes raciocinem e ajam quase em tempo real. Essa é a diferença entre um agente que parece um job em batch que você enviou e um que parece um colaborador trabalhando ao seu lado.
Taxas previsíveis permitem planejamento: Agentes precisam orçar para as operações. O modelo de taxas da Solana, cerca de $0,00025 por transação, permite que desenvolvedores construam agentes que podem operar indefinidamente com capital mínimo. As priority fees durante congestionamento permanecem razoáveis em comparação aos leilões de gas encontrados em outras chains.
Composabilidade nativa de programas: Programas Solana podem chamar outros programas atomicamente dentro de uma única transação. Um agente pode trocar tokens na Jupiter, fazer stake do resultado na Marinade e mintar um NFT de recibo, tudo em uma única operação atômica. Essa composabilidade é o que separa os agentes na Solana de fluxos sequenciais desajeitados. Quando um agente consegue agrupar múltiplas operações em uma única transação atômica, digamos, trocar tokens, fornecer liquidez e fazer stake da posição de LP, ele executa mais rápido (uma confirmação vs. três), custa menos (uma taxa base vs. três) e exige código mais simples (sem tratamento de erro entre etapas). Para os usuários, a diferença é enorme: peça ao agente para "otimizar meu yield" e ele simplesmente faz isso em segundos, em vez de guiá-lo por um processo de múltiplas etapas com prompts de confirmação em cada estágio.
Momentum do ecossistema: O ecossistema de agentes de IA na Solana explodiu desde o final de 2024. Solana Agent Kit da SendAI, ElizaOS (anteriormente ai16z), o GOAT toolkit da Crossmint, e frameworks nativos em Rust como Rig criaram um ambiente de desenvolvimento rico. A Jupiter processa 90% do volume dos agregadores DEX da Solana com APIs projetadas para acesso programático, facilitando muito para que agentes se conectem e utilizem esses dados.

Entendendo o stack de agentes de IA

Antes de entrar no código, vamos dar uma visão geral rápida das camadas do stack de agentes de IA, o que pode ajudar a entender quais ferramentas usar para cada tarefa. O stack de agentes de IA pode ser resumido em 4 camadas:

Large Language Models (LLMs): LLMs formam a base de qualquer agente de IA. Os modelos mais recentes, como Claude Opus 4.5, GPT-5.2 ou Gemeni 2.5 Pro, fornecem a compreensão de linguagem natural e as capacidades de raciocínio. Eles processam solicitações do usuário, interpretam dados blockchain ingeridos e decidem quais ações tomar. O LLM é o "cérebro" que torna um agente inteligente em vez de apenas um script.
Frameworks de agentes: Frameworks ficam acima dos LLMs e cuidam da orquestração de como o agente vai funcionar. Eles gerenciam o histórico de conversas, mantêm a "personalidade" do agente através de system prompts, coordenam múltiplas ferramentas e se integram com plataformas externas como Twitter, Discord ou Telegram. ElizaOS é o exemplo líder, combinando integração com LLM, gerenciamento de memória e clientes multi-plataforma em um framework unificado.
Toolkits de blockchain: Toolkits dão aos agentes a capacidade de de fato interagir com a Solana. O Solana Agent Kit, o GOAT toolkit e bibliotecas similares expõem operações blockchain como "ferramentas" que os LLMs podem invocar. Quando um usuário diz "troque 10 SOL por USDC", o toolkit traduz isso em chamadas à API da Jupiter, construção de transações e envio.

O panorama dos frameworks de agentes

Com a base conceitual coberta, vamos falar sobre os quatro principais frameworks que dominarão o desenvolvimento de agentes de IA na Solana em 2026.

Solana Agent Kit (SendAI)

O Solana Agent Kit é o caminho mais direto para construir agentes que interagem com o ecossistema Solana. Desenvolvido pela SendAI, ele fornece mais de 60 ações pré-construídas cobrindo operações com tokens, mintagem de NFTs, interações DeFi e mais. O kit se integra de forma limpa com LangChain, Vercel AI SDK e outros frameworks populares de desenvolvimento de IA.

A arquitetura modular de plugins da SendAI permite instalar apenas o que você precisa. O plugin de tokens cuida de transferências e trocas de tokens SPL. O plugin de NFT gerencia operações do Metaplex. O plugin de DeFi se integra com Jupiter, Raydium e outros protocolos. Essa modularidade mantém os deployments leves.

Veja como é a inicialização desse framework. Primeiro, você cria uma wallet, instancia o agente com seu RPC e chaves de API, depois encadeia os plugins necessários:

typescriptCopied
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);

Ideal para: Desenvolvedores que querem prototipagem rápida com cobertura abrangente da Solana. O kit abstrai a maior parte da complexidade blockchain enquanto permanece flexível o suficiente para uso em produção.

ElizaOS

O ElizaOS evoluiu do projeto ai16z para um sistema operacional de agentes completo. É projetado para agentes autônomos que mantêm personalidades persistentes em várias plataformas, bots de Twitter, assistentes de Discord e canais de Telegram. O framework cuida da memória, definições de personagem e deployment multi-plataforma.

Agentes no ElizaOS são definidos através de arquivos JSON de personagem que especificam personalidade, ações disponíveis e parâmetros comportamentais. O plugin Solana fornece capacidades blockchain, e o framework gerencia a complexidade de manter um comportamento de agente coerente ao longo das interações.

Começar é simples com a CLI:

bashCopied
# Install ElizaOS CLI
bun install -g @elizaos/cli

# Create a new agent project

elizaos create my-solana-agent

# Start in development mode

elizaos dev

A configuração real acontece no seu arquivo de personagem. É aí que você define em quais plataformas o agente opera, qual provedor de LLM usar e quais capacidades Solana habilitar:

jsonCopied
{
"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"
  }
}
}

Ideal para: Agentes sociais que precisam de identidade persistente em várias plataformas. Se você está construindo um bot de Twitter ou assistente de Discord com capacidades Solana, o ElizaOS é a escolha natural.

GOAT toolkit (Crossmint)

O GOAT (Great Onchain Agent Toolkit) adota uma abordagem diferente. É projetado como um adaptador universal entre agentes de IA e qualquer aplicação blockchain. Enquanto o Solana Agent Kit foca em operações específicas da Solana, o GOAT fornece uma interface unificada em mais de 30 chains, incluindo Solana, redes EVM e outras.

O verdadeiro poder do GOAT está na amplitude de suas integrações. Mais de 200 plugins cobrem protocolos desde Jupiter e Orca na Solana até Uniswap e Aave na Ethereum. Se você está construindo agentes que precisam operar em múltiplas chains, o GOAT elimina a necessidade de implementações específicas por chain.

O padrão de inicialização é parecido com o do Solana Agent Kit. Primeiro você inicializa uma wallet, seleciona seus plugins e gera ferramentas para seu framework de IA. Aqui está uma configuração Solana com integração Jupiter:

typescriptCopied
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()]
});

Ideal para: Agentes multi-chain e aplicações que precisam se integrar com protocolos DeFi específicos. O ecossistema de plugins do GOAT é imbatível em cobertura de protocolos.

Rig framework (Rust)

Para aplicações críticas em performance, bots de trading de alta frequência, estratégias de MEV, operações sensíveis à latência, o Rig fornece um framework de agentes de IA nativo em Rust. Combinado com Listen.rs para integração com a Solana, oferece o caminho de menor latência da decisão do LLM até a execução onchain.

O Rig aproveita o sistema de tipos do Rust para correção em tempo de compilação e suas características de performance para operações sub-milissegundo. O rig-onchain-kit fornece integração com a Solana, e o Listen.rs adiciona monitoramento de transações e submissão de bundles Jito para transações protegidas contra MEV.

A API é limpa e idiomática em Rust. Você cria um cliente, configura um agente com um system prompt e começa a enviar prompts:

rustCopied
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?;

}

Ideal para: Aplicações críticas em performance onde a latência importa. Se você está construindo infraestrutura de trading ou precisa de integração direta com o ecossistema Rust nativo da Solana, o Rig é a escolha.

LangChain

O LangChain é o framework mais amplamente adotado para construir aplicações com LLM. Embora não seja específico para blockchain, sua abstração de ferramentas e arquitetura de agentes o tornam uma escolha natural para desenvolvimento na Solana. O Solana Agent Kit fornece integração de primeira classe com o LangChain, permitindo que você aproveite o ecossistema maduro do LangChain enquanto acessa as capacidades onchain da Solana.

A força do LangChain é a composabilidade, permitindo que desenvolvedores encadeiem prompts, ferramentas, sistemas de memória e mecanismos de recuperação em fluxos de agentes complexos. O framework cuida do gerenciamento de conversas, seleção de ferramentas e parsing de output. Para agentes Solana, isso significa que você pode combinar ações onchain com fontes de dados off-chain, pipelines RAG e raciocínio em múltiplas etapas.

A integração com o Solana Agent Kit é perfeita. Você inicializa seu agente e, em seguida, usa o helper createLangchainTools para gerar ferramentas compatíveis com o LangChain a partir das suas ações Solana:

typescriptCopied
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" }]
});

O LangChain também brilha quando você precisa combinar operações Solana com dados externos. Você pode adicionar ferramentas de busca na web, recuperadores de banco de dados ou integrações de API personalizadas junto com suas ferramentas blockchain. O agente decide quais ferramentas usar com base na tarefa.

Ideal para: Desenvolvedores que já trabalham no ecossistema LangChain, ou aplicações que precisam combinar operações Solana com cadeias de raciocínio complexas, RAG ou fontes de dados externas. Se seu agente precisa de mais do que apenas interações blockchain, o LangChain fornece a camada de orquestração.

Construindo seu primeiro agente Solana: passo a passo

Agora que cobrimos a teoria fundamental, vamos construir um agente de IA Solana funcional usando o Solana Agent Kit e o LangChain. Ao final desta seção, você terá um agente que pode checar saldos, executar trocas e mintar NFTs de recibo financeiro, tudo através de comandos em linguagem natural.

Vamos construir isso incrementalmente, explicando cada parte ao longo do caminho.

Pré-requisitos

Antes de começar, certifique-se de ter:

Node.js v23+: O Solana Agent Kit exige recursos modernos do Node. Verifique sua versão com node --version. Se precisar atualizar, o nvm facilita:

bash

Copied

nvm install 23
nvm use 23

Uma wallet Solana: Você precisará de um keypair com algum SOL de devnet para testes. Vamos gerar um caso você não tenha. - Chaves de API: OpenAI (para o LLM) e opcionalmente um provedor RPC dedicado como a Alchemy

Configuração do projeto

Comece criando um novo diretório e inicializando seu projeto:

bash

Copied

mkdir solana-agent
cd solana-agent
pnpm init

Agora instale as dependências. Cada pacote tem um propósito específico:

bash

Copied

pnpm add solana-agent-kit @langchain/core @langchain/openai @langchain/langgraph dotenv bs58

Veja o que cada dependência faz:

solana-agent-kit: O toolkit principal que fornece ações Solana como ferramentas compatíveis com LLM
@langchain/core: Abstrações base para mensagens, prompts e interfaces de ferramentas
@langchain/openai: Integração OpenAI para o LangChain (GPT-4 como nosso motor de raciocínio)
@langchain/langgraph: Fornece o padrão de agente ReAct—o loop em que o LLM raciocina sobre qual ferramenta usar, a usa, observa o resultado e decide o que fazer em seguida
dotenv: Carrega variáveis de ambiente de um arquivo .env
bs58: Codificação/decodificação Base58 para chaves privadas Solana

Configuração do ambiente

Crie um arquivo .env na raiz do seu projeto. Isso mantém credenciais sensíveis fora do seu código:

bash

Copied

OPENAI_API_KEY=your_openai_api_key
RPC_URL=https://api.devnet.solana.com
SOLANA_PRIVATE_KEY=[your,private,key,as,byte,array]

Uma observação sobre o formato da chave privada: keypairs Solana são arrays de 64 bytes. O arquivo .env armazena isso como um array JSON como \[123,45,67,...\]. Se você precisar gerar um novo keypair para testes, use:

bash

Copied

solana-keygen grind --starts-with ai:1

Isso cria um endereço vanity começando com "ai" (útil para identificar a wallet do seu agente). O output inclui o keypair como um array de bytes que você pode colar no seu .env.

Importante: Nunca use um keypair com fundos reais para desenvolvimento. Sempre teste primeiro na devnet.

Entendendo a arquitetura do nosso agente

Antes de escrever código, vamos entender o que estamos construindo. Nosso agente tem três componentes principais:

O LLM (GPT-5.2): O "cérebro" que entende linguagem natural, raciocina sobre quais ações tomar e gera respostas
As Ferramentas (Solana Agent Kit): Funções que o LLM pode chamar—verificar saldo, trocar tokens, mintar NFTs, etc.
O Loop do Agente (LangGraph ReAct): O LangchainReAct é uma implementação da arquitetura de agentes Reasoning and Acting (ReAct) usando o framework LangGraph. Esse padrão de orquestração conecta o LLM e as ferramentas. Quando você envia uma mensagem, o agente recebe seu input → decide se uma ferramenta é necessária → chama a ferramenta → observa o resultado → decide se mais ferramentas são necessárias → gera uma resposta

Esse é o padrão ReAct (Reasoning + Acting). O LLM não apenas responde, ele raciocina sobre quais ações tomar, as toma e incorpora os resultados na sua resposta.

O script do agente

Agora vamos construir o agent.ts. Vamos passar seção por seção.

Imports e configuração

typescriptCopied
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();

Os imports se dividem em três categorias: Solana Agent Kit para operações blockchain, LangChain para orquestração de IA, e utilitários do Node para variáveis de ambiente e input do usuário.

Inicializando o agente

A função initializeAgent configura todos os componentes:

typescriptCopied
async function initializeAgent() {
// Step 1: Initialize the LLM
const llm = new ChatOpenAI({
  modelName: "gpt-4-turbo-preview",
  temperature: 0.7
});

Estamos usando o GPT-5.2 como motor de raciocínio. O temperature de 0,7 equilibra criatividade com consistência, valores mais baixos tornam as respostas mais determinísticas, valores mais altos tornam-nas mais variadas. Para um agente que precisa tomar decisões confiáveis sobre transações financeiras, você pode reduzir esse valor para 0,3.

typescriptCopied
// 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);

Esse trecho converte a chave privada do formato de array JSON no nosso .env para a string base58 que o Solana Agent Kit espera. O caminho de conversão: string JSON → array JavaScript → Uint8Array → string base58.

typescriptCopied
// Step 3: Initialize Solana Agent Kit
const solanaKit = new SolanaAgentKit(
privateKeyBase58,
process.env.RPC_URL!,
{ OPENAI_API_KEY: process.env.OPENAI_API_KEY! }
);

A instância SolanaAgentKit conecta sua wallet à rede Solana. Ela recebe três argumentos: a chave privada (para assinar transações), a URL do RPC (para comunicação com a rede) e opções de configuração (incluindo a chave OpenAI para quaisquer operações internas de IA).

typescriptCopied
// Step 4: Create tools from the kit
const tools = createSolanaTools(solanaKit);

É aqui que a mágica acontece. O createSolanaTools transforma as capacidades do Solana Agent Kit em ferramentas compatíveis com LangChain. Cada ferramenta tem um nome, descrição e input schema que o LLM usa para entender o que ela pode fazer e como chamá-la. Por baixo dos panos, você está obtendo ferramentas como get\_balance, transfer, swap, deploy\_token, mint\_nft, e dezenas de outras.

typescriptCopied
// Step 5: Set up memory for conversation context
const memory = new MemorySaver();

A memória permite que o agente mantenha contexto ao longo de múltiplos turnos. Sem ela, cada mensagem seria tratada isoladamente, o agente não se lembraria que você acabou de perguntar sobre seu saldo quando você responder com "troque metade disso".

typescriptCopied
  // Step 6: Create the ReAct agent
return createReactAgent({
  llm,
  tools,
  checkpointSaver: memory
});
}

Finalmente, montamos tudo em um agente ReAct. Isso cria o loop de raciocínio: o LLM recebe o input, decide qual ferramenta (se alguma) usar, a executa, observa o resultado e ou toma outra ação ou responde ao usuário.

O loop de chat interativo

A segunda função cria uma interface de terminal para conversar com seu agente:

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

O thread\_id identifica essa conversa para fins de memória. Se você reiniciar o script com o mesmo thread ID, o agente (em teoria) se lembraria do contexto anterior. IDs de thread diferentes significam contextos de conversa diferentes.

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

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

Configuração padrão do readline do Node.js para input/output de terminal, que cria uma interface readline que captura o input do teclado no terminal (stdin) e escreve as respostas do agente de volta na sua tela (stdout). É a forma mais simples de construir um chat interativo de linha de comando sem adicionar dependências extras.

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

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

Quando você digita uma mensagem, ela é envolvida em um HumanMessage e enviada ao agente. Usamos stream em vez de invoke para obter output em tempo real enquanto o agente pensa e age.

typescriptCopied
      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);

O loop de streaming lida com dois tipos de chunks: chunks agent (o raciocínio e as respostas do LLM) e chunks tools (resultados de execuções de ferramentas). Isso permite que você veja o que está acontecendo em tempo real—o agente pensando, chamando ferramentas e formulando sua resposta.

O script completo

Aqui está o agent.ts completo para referência:

typescriptCopied
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);

Executando o agente

Execute com tsx (execução TypeScript):

bash

Copied

npx tsx agent.ts

Você deve ver a mensagem de pronto. Agora tente alguns comandos:

text

Copied

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/...

O que está acontecendo por baixo dos panos: quando você pergunta sobre seu saldo, o LLM reconhece que isso exige a ferramenta get\_balance, a chama com os parâmetros corretos, recebe o resultado e o incorpora em uma resposta em linguagem natural. Para trocas, ele identifica a ferramenta swap, interpreta sua intenção (0,1 SOL → USDC), executa a troca via Jupiter e confirma a transação.

O que você construiu

Agora você tem um agente de IA Solana funcional com:

Compreensão de linguagem natural via GPT-5.2
Mais de 60 operações Solana disponíveis como ferramentas
Memória de conversa para interações de múltiplos turnos
Respostas em streaming em tempo real

Essa é uma base de desenvolvimento. O deployment em produção exige considerações adicionais, segurança de wallet, confiabilidade de transações, rate limiting, que abordaremos em seções posteriores.

Integrando a Jupiter para operações DeFi

A Jupiter é o agregador DEX dominante da Solana, roteando mais de 90% do volume de agregadores. Quando seu agente precisa trocar tokens, a Jupiter encontra a melhor rota entre dezenas de DEXs, Raydium, Orca, Phoenix e outras—para obter o preço ótimo.

O Solana Agent Kit inclui integração com a Jupiter nativamente. Quando você pede ao seu agente para "trocar 1 SOL por USDC", ele já está usando a Jupiter por baixo dos panos. Mas às vezes você precisa de mais controle: tolerâncias de slippage personalizadas, preferências de roteamento específicas ou integração direta com seu próprio pipeline de transações.

Como a Jupiter funciona

A API da Jupiter segue um padrão de quote-depois-swap:

Quote: Você envia o token de entrada, o token de saída e o valor. A Jupiter consulta todas as DEXs disponíveis e retorna a melhor rota com os valores de saída esperados.
Swap: Você envia o quote de volta com o endereço da sua wallet. A Jupiter constrói uma transação que executa a rota ótima.
Assinar e Enviar: Você assina a transação e a envia para a rede.

Esse processo em duas etapas permite mostrar aos usuários o que eles receberão antes de se comprometerem com a troca.

Integração direta com a Jupiter

Aqui está uma função de swap completa com explicação passo a passo:

typescriptCopied
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";

Começamos com os imports padrão do Solana web3.js e o cliente de API da Jupiter. Os endereços mint são os identificadores únicos para tokens na Solana. O SOL usa um endereço "wrapped" especial para compatibilidade com DEXs.

typescriptCopied
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();

O cliente da Jupiter se conecta à API hospedada por eles. Nenhuma chave de API é necessária para uso básico, embora limites de taxa se apliquem.

typescriptCopied
// Step 1: Get a quote
const quote = await jupiter.quoteGet({
inputMint,
outputMint,
amount,
slippageBps: 50  // 0.5% slippage tolerance
});

A requisição de quote especifica o que você está negociando. slippageBps é a tolerância de slippage em pontos-base, 50 significa 0,5%. Se o preço se mover mais que isso entre o quote e a execução, a transação falha em vez de lhe dar uma taxa pior.

A resposta do quote inclui o valor de saída esperado, a rota (quais DEXs serão usadas) e o impacto no preço. Para agentes em produção, você vai querer verificar esses valores antes de prosseguir.

typescriptCopied
// Step 2: Get the swap transaction
const { swapTransaction } = await jupiter.swapPost({
swapRequest: {
  quoteResponse: quote,
  userPublicKey: wallet.publicKey.toString(),
  wrapAndUnwrapSol: true  // Automatically handle SOL wrapping
}
});

A requisição de swap pega seu quote e o endereço da wallet e retorna uma transação serializada. wrapAndUnwrapSol: true lida com uma peculiaridade da Solana: DEXs trabalham com "wrapped SOL" (um token SPL), mas usuários têm SOL nativo. Essa flag adiciona instruções para empacotar antes e desempacotar depois da troca automaticamente.

typescriptCopied
// Step 3: Deserialize and sign
const transaction = VersionedTransaction.deserialize(
Buffer.from(swapTransaction, "base64")
);
transaction.sign([wallet]);

A Jupiter retorna a transação como uma string codificada em base64. Nós a desserializamos em um objeto de transação adequado e a assinamos com nosso keypair. Note que estamos usando VersionedTransaction,. A Jupiter usa o formato de transação mais novo da Solana, que suporta address lookup tables para rotas mais complexas.

typescriptCopied
  // Step 4: Submit and confirm
const signature = await connection.sendTransaction(transaction);
await connection.confirmTransaction(signature);

return signature;
}

Finalmente, enviamos a transação assinada para a rede e aguardamos a confirmação. A assinatura é um identificador único que você pode usar para consultar a transação em exploradores como o Solscan.

Servidor MCP da Jupiter

Para assistentes de IA que suportam o Model Context Protocol (como Claude Desktop ou Cursor), a Jupiter oferece um servidor MCP. Isso dá ao seu assistente de IA acesso direto às capacidades da Jupiter através de uma interface padronizada.

Configure-o nas suas configurações MCP:

jsonCopied
{
"mcpServers": {
  "jupiter": {
    "command": "npx",
    "args": ["jupiter-ultra-mcp"],
    "env": {
      "RPC_URL": "your_rpc_url",
      "PRIVATE_KEY": "your_private_key"
    }
  }
}
}

Uma vez configurado, o Claude pode executar trocas via Jupiter diretamente através de linguagem natural: "Troque 0,5 SOL por USDC" se torna uma transação onchain real. Isso é particularmente poderoso para prototipagem rápida: você pode construir e testar fluxos DeFi através de conversa antes de se comprometer com código.

Arquitetura de segurança de wallet

Um agente de IA com autoridade de assinatura é um alvo de alto valor. Um agente comprometido pode drenar sua wallet instantaneamente. A arquitetura de segurança deve equilibrar autonomia com proteção.

A arquitetura de chave dupla

O padrão emergente para wallets de agentes seguras usa uma arquitetura de chave dupla com wallets de smart contract:

Wallet de smart contract: Uma única wallet (usando padrões ERC-4337 no EVM ou o protocolo Squads na Solana) que pode ter múltiplos signatários autorizados.

Chave do proprietário: Mantida pelo usuário, fornece controle total. Com ela, você pode adicionar/remover chaves de agente, retirar fundos e sobrepor ações do agente.

Chave do agente: Implantada dentro de um Trusted Execution Environment (TEE), registrada na smart wallet com permissões limitadas. Com essa chave, o agente só pode realizar operações autorizadas.

A implementação da Crossmint torna isso simples. Você cria uma wallet custodial vinculada a uma identidade de usuário, e o agente opera dentro das permissões que você define:

typescriptCopied
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

Proteção TEE

Trusted Execution Environments fornecem isolamento em nível de hardware para chaves de agentes. Plataformas como Phala Network e Turnkey oferecem infraestrutura TEE projetada especificamente para agentes de IA.

A Turnkey fornece acesso à wallet controlado por políticas. Em vez de expor chaves privadas, agentes recebem credenciais de API com escopo limitado que só podem realizar operações autorizadas. Você define políticas que limitam tipos de transação, valores e taxas—então o agente opera dentro dessas barreiras de proteção:

typescript

Copied

`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`

A Phala Network fornece infraestrutura TEE descentralizada. Agentes implantados na Phala rodam em enclaves isolados onde nem mesmo o sistema hospedeiro pode acessar as chaves privadas. O deployment é baseado em containers:

bashCopied
# 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

Boas práticas de segurança

Vários princípios devem guiar a arquitetura de segurança de agentes:

Minimize a exposição de chaves: Chaves privadas nunca devem aparecer em logs, mensagens de erro ou memória acessível. Use variáveis de ambiente e infraestrutura segura de gerenciamento de chaves.
Implemente limites de transação: Agentes devem ter tamanhos máximos de transação, limites diários de gastos e rate limits. Um agente comprometido com autoridade ilimitada pode causar danos ilimitados.
Use wallets separadas: Agentes em produção devem usar wallets dedicadas com apenas os fundos necessários para as operações. Nunca conecte um agente a uma wallet contendo ativos significativos.
Monitore a atividade do agente: Registre todas as transações do agente e implemente alertas para padrões incomuns. O monitoramento automatizado pode detectar comprometimentos antes que danos significativos ocorram.
Teste primeiro na devnet: Sempre desenvolva e teste agentes na devnet antes do deployment na mainnet. A URL do RPC é tipicamente a única mudança necessária para trocar de rede.

Integração com o Model Context Protocol (MCP)

O Model Context Protocol padroniza como assistentes de IA interagem com ferramentas externas. Para desenvolvimento na Solana, servidores MCP permitem que o Claude, o Cursor e outras ferramentas de IA interajam diretamente com a blockchain.

Servidor MCP da Solana

O servidor MCP da Solana da SendAI fornece ferramentas blockchain para qualquer assistente de IA compatível com MCP:

bash

Copied

# Install globally
npm install -g solana-mcp

# Or run directly

npx solana-mcp

As ferramentas disponíveis no servidor MCP incluem:

GET\_ASSET: Recuperar informações de token/NFT
GET\_BALANCE: Verificar saldos de wallet
TRANSFER: Enviar SOL ou tokens SPL
SWAP: Executar trocas via Jupiter
DEPLOY\_TOKEN: Criar novos tokens SPL
MINT\_NFT: Mintar NFTs via Metaplex

Construindo com o ElizaOS: exemplo de bot de Twitter

Até agora, construímos um agente funcional que consegue raciocinar, executar transações Solana e manter contexto de conversa, tudo a partir do terminal. Agora vamos pegar essas mesmas capacidades e implantá-las onde os usuários de fato estão: o Twitter, usando o ElizaOS.

O ElizaOS brilha para agentes sociais, bots que mantêm personalidades persistentes em várias plataformas. Vamos construir um bot de Twitter.

O que estamos construindo

Esse bot vai:

Monitorar o Twitter em busca de menções perguntando sobre tokens, protocolos ou condições de mercado
Buscar dados onchain: preços de tokens, volume de negociação, profundidade de liquidez, movimentos de whales
Analisar e resumir os dados em linguagem simples
Manter uma personalidade de "analista" consistente em todas as interações

O ElizaOS cuida da orquestração complexa: observar menções, manter contexto de conversa, decidir quando consultar dados onchain e gerar respostas que combinem com a personalidade definida.

Entendendo a arquitetura do ElizaOS

Antes de entrar no código, vamos entender como o ElizaOS estrutura um agente:

Clients conectam o agente a plataformas, Twitter, Discord, Telegram ou acesso direto via API. Cada client cuida da autenticação específica da plataforma, do polling de mensagens e da formatação de respostas.

Plugins fornecem capacidades. O plugin Solana dá ao seu agente ferramentas para ler dados onchain, buscar tokens e consultar histórico de transações. Outros plugins podem adicionar geração de imagens, busca na web ou ações personalizadas.

Arquivos de personagem definem personalidade e comportamento através de JSON estruturado. Isso inclui bio, estilo de comunicação, exemplos de conversas e parâmetros comportamentais.

Memória persiste entre conversas. O ElizaOS rastreia com quem o agente já conversou, quais perguntas fizeram e o contexto relevante para interações futuras.

Configuração

Comece clonando o repositório do ElizaOS:

bash

Copied

git clone https://github.com/elizaOS/eliza.git
cd eliza

O ElizaOS é um monorepo contendo o framework principal, todos os plugins oficiais e implementações de clients. Vamos trabalhar dentro dessa estrutura em vez de criar um projeto separado.

Instale as dependências e faça o build:

bash

Copied

pnpm install --no-frozen-lockfile
pnpm build

A flag --no-frozen-lockfile permite que o pnpm atualize o lockfile se necessário. A etapa de build compila o TypeScript e prepara todos os pacotes.

Configuração do ambiente

Crie um arquivo .env na raiz do projeto. O ElizaOS lê isso para todas as credenciais e configurações:

bash

Copied

# Twitter credentials
TWITTER_USERNAME=your_bot_username
TWITTER_PASSWORD=your_password
TWITTER_EMAIL=your_email

A autenticação do Twitter usa as credenciais da conta do seu bot. O ElizaOS faz login e mantém uma sessão para fazer polling de menções e postar respostas. Certifique-se de usar uma conta de bot dedicada—você não quer seu Twitter pessoal rodando um agente automatizado.

bash

Copied

# LLM provider
OPENAI_API_KEY=your_openai_key

O provedor do modelo alimenta o raciocínio do agente. O ElizaOS suporta múltiplos provedores (OpenAI, Anthropic, modelos locais), mas a OpenAI é a mais direta para começar.

bash

Copied

# 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

Para um bot analista, você não precisa de uma chave privada—estamos lendo dados, não assinando transações. Use um RPC de mainnet já que você quer dados reais de mercado, não tokens de teste da devnet. Um provedor RPC dedicado como a Alchemy lhe dá limites de taxa mais altos e dados mais confiáveis do que o endpoint público.

Nota de segurança: Mesmo esse bot só lendo dados, proteja suas chaves de API. Os limites de taxa do seu provedor RPC estão vinculados a essas credenciais.

Entendendo os arquivos de personagem

Arquivos de personagem são o coração de um agente ElizaOS. Eles definem não apenas o que o agente pode fazer, mas quem ele é. Vamos construir um peça por peça.

Crie characters/solana-analyst.character.json:

jsonCopied
{
"name": "SolanaAnalyst",
"clients": ["twitter"],
"modelProvider": "openai",
"plugins": ["@elizaos/plugin-solana"],

O cabeçalho define o básico:

name: Como o agente se identifica
clients: Em quais plataformas conectar. Adicionar "discord" aqui habilitaria integração com Discord sem código adicional.
modelProvider: Qual LLM usar para raciocínio
plugins: Capacidades a habilitar. O plugin Solana fornece consultas de dados de tokens, feeds de preço e análises onchain.

jsonCopied
"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 é um array de declarações que definem a autodescrição do agente. O ElizaOS usa isso quando o agente precisa se apresentar ou responder perguntas do tipo "quem é você?". Múltiplas entradas adicionam variedade—o agente pode recorrer a linhas de bio diferentes em contextos diferentes.

jsonCopied
"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 fornece contexto de background que o agente pode referenciar. Isso não é exposto diretamente aos usuários, mas influencia como o agente entende seu próprio propósito e história. Pense nisso como o backstory interno do agente.

jsonCopied
"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 são exemplos few-shot que ensinam ao agente como responder. Cada exemplo é um array de conversa mostrando o input do usuário e a resposta esperada do agente. Note como os exemplos estabelecem o tom: orientado a dados, números específicos, contexto acionável, sem enrolação.

Adicione mais exemplos para cobrir casos extremos: e se alguém perguntar sobre um token que não existe? E se quiserem uma análise comparativa? E se estiverem perguntando sobre um token golpe? Quanto mais cenários você cobrir, mais consistente será o comportamento do agente.

jsonCopied
  "style": {
  "all": ["data-driven", "concise", "insightful", "avoids hype"],
  "chat": ["direct", "analytical", "provides context for numbers"],
  "post": ["informative", "highlights unusual activity", "actionable"]
}
}

style define padrões de comunicação em diferentes contextos:

all: Se aplica a todas as respostas
chat: Específico para mensagens diretas e respostas
post: Para posts originais que o agente cria

Essas são palavras-chave descritivas que influenciam o tom do LLM. "evita hype" é importante para um analista financeiro—você quer análise ponderada, não "SOL TO THE MOON 🚀". "fornece contexto para números" garante que o agente não apenas cuspa preços, mas explica o que eles significam.

O arquivo de personagem completo

Aqui está a definição completa de personagem:

jsonCopied
{
"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"]
}
}

Inicie seu agente

Inicie o agente com seu arquivo de personagem:

bash

Copied

pnpm start --character="characters/solana-analyst.character.json"

Você verá logs à medida que o ElizaOS:

Carrega a definição de personagem
Inicializa o provedor OpenAI
Conecta ao Twitter
Carrega o plugin Solana
Começa a fazer polling de menções

O que acontece quando alguém tweeta

Quando um usuário tweeta "@SeuBot qual é o volume de BONK hoje?", aqui está o fluxo:

O client do Twitter detecta a menção através de polling
O handler de mensagem interpreta o tweet e cria um contexto de conversa
O LLM recebe a mensagem junto com a definição de personagem, bio e exemplos
A seleção de ferramenta reconhece isso como uma consulta de dados e seleciona a ação apropriada do plugin Solana
A execução do plugin busca dados do token no RPC e agrega preços da Jupiter
A geração de resposta cria uma resposta que contextualiza os dados brutos
O client do Twitter posta a resposta como uma thread

O agente mantém memória dessa interação. Se o mesmo usuário perguntar "como isso se compara a ontem?" uma hora depois, o agente pode referenciar a conversa anterior e fornecer uma análise comparativa.

Estendendo o bot

A abordagem de arquivo de personagem torna a iteração rápida. Quer adicionar suporte ao Discord?

jsonCopied
"clients": ["twitter", "discord"]

Adicione variáveis de ambiente para o Discord, reinicie, e seu agente agora opera em ambas as plataformas com a mesma personalidade.

Quer adicionar alertas proativos? Você pode configurar o agente para postar quando detectar atividade incomum:

jsonCopied
"settings": {
"autoPost": true,
"postInterval": 3600,
"postTopics": ["whale movements", "unusual volume", "TVL changes"]
}

Agora o agente monitorará independentemente a atividade onchain e tuitará quando algo notável acontecer—sem necessidade de prompt do usuário.

Considerações de produção para bots sociais

O Twitter tem limites de taxa e políticas de automação. Para deployment em produção:

Rate limiting: Não responda a cada menção instantaneamente. Adicione atrasos que imitam tempos de resposta humanos.
Políticas de conteúdo: As regras de automação do Twitter exigem divulgação clara de que a conta é um bot. Coloque isso na sua bio.
Precisão dos dados: Seu bot está fornecendo informações financeiras. Adicione disclaimers, cite fontes de dados e seja claro sobre limitações. "Não é aconselhamento financeiro" não é apenas cobertura jurídica—é responsabilidade.
Tratamento de erros: Chamadas RPC podem falhar, dados podem ficar desatualizados, tokens podem ser deslistados. Lide com isso de forma elegante em vez de postar erros publicamente.
Monitoramento: Acompanhe quais consultas o bot trata e quais respostas gera. Você quer visibilidade sobre o que ele está dizendo, especialmente quando os mercados estão voláteis.

Ferramentas de agente: CLI, Skills e MCP

Frameworks cuidam da orquestração. O Alchemy for agents cobre a camada de infraestrutura.

Instale o Alchemy Skills, conecte o servidor MCP e autentique a CLI:

bashCopied
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

Consulte pelo terminal:

bash

Copied

alchemy --json --no-interactive solana rpc getSlot -n solana-mainnet
alchemy --json --no-interactive prices symbol SOL,ETH
alchemy --json --no-interactive agent-prompt

Conclusão

Você acabou de construir seu primeiro agente de IA na Solana. Se há um ponto para lembrar deste tutorial, é que a infraestrutura para construir agentes de IA na Solana amadureceu dramaticamente.

A chain é rápida. Os frameworks estão prontos. A pergunta é o que você vai construir com eles.

Pronto para começar? A Alchemy fornece a infraestrutura RPC que alimenta os principais agentes de IA e frameworks na Solana. Seja você precisando de endpoints de baixa latência, APIs aprimoradas para operações com tokens, ou suporte multi-chain para agentes multi-plataforma, a plataforma da Alchemy lhe dá a base para construir agentes de IA de nível produção que podem operar em escala.

Perguntas frequentes

Quais ferramentas vocês recomendam para construir agentes de IA na Solana?

Sugerimos usar Solana Agent Kit, ElizaOS, GOAT toolkit e Rig framework dependendo do seu caso de uso. O Solana Agent Kit oferece prototipagem rápida com mais de 60 ações pré-construídas, o ElizaOS se destaca em agentes sociais em várias plataformas, o GOAT fornece suporte multi-chain, e o Rig entrega desenvolvimento nativo em Rust crítico em performance.

Por que a Solana é preferida para desenvolvimento de agentes de IA?

Os blocos de 400ms e a finalidade em menos de um segundo da Solana permitem loops de feedback em tempo real, permitindo que agentes raciocinem, ajam e observem resultados rapidamente. As taxas de transação têm média de $0,00025, tornando operações de alta frequência economicamente viáveis, e a composabilidade nativa de programas permite que agentes executem operações complexas de múltiplas etapas em transações atômicas únicas.

Quais linguagens de programação são melhores para construir agentes de IA na Solana?

TypeScript com Solana Agent Kit ou LangChain é ideal para desenvolvimento rápido e integração ampla com o ecossistema. Para aplicações críticas em performance, como trading de alta frequência ou estratégias de MEV, Rust com o framework Rig oferece o caminho de menor latência da decisão do LLM até a execução onchain.

Como devo proteger a wallet do meu agente de IA?

Use uma arquitetura de chave dupla com wallets de smart contract, onde a chave do proprietário fornece controle total e a chave do agente opera dentro de um Trusted Execution Environment (TEE) com permissões limitadas. Nunca exponha chaves privadas em logs, implemente limites de transação, use wallets separadas com fundos mínimos e sempre teste primeiro na devnet.

Posso construir um agente de IA que opera no Twitter ou no Discord?

Sim, o ElizaOS permite que agentes mantenham personalidades persistentes no Twitter, Discord, Telegram e outras plataformas simultaneamente. Você define o comportamento do agente através de um arquivo JSON de personagem, e o ElizaOS cuida da autenticação específica de cada plataforma, do polling de mensagens e da formatação de respostas.

Como integro a Jupiter para trocas de tokens no meu agente?

O Solana Agent Kit inclui integração com a Jupiter nativamente através de ações de swap pré-construídas. Para implementações personalizadas, use o padrão de API quote-depois-swap da Jupiter: solicite um quote com seu par de negociação, construa a transação de swap com o endereço da sua wallet, depois assine e envie a transação versionada.

O que é o Model Context Protocol (MCP) e como ele ajuda?

O MCP padroniza como assistentes de IA interagem com ferramentas externas. O servidor MCP da Solana permite que o Claude, o Cursor e outras ferramentas de IA compatíveis com MCP executem operações blockchain diretamente através de linguagem natural, incluindo verificações de saldo, transferências de tokens, trocas e mintagem de NFTs.

Quais são os erros comuns ao construir agentes de IA na Solana?

Código gerado por IA pode produzir atualizações sequenciais de contas em vez de processamento paralelo ou ignorar otimizações específicas da Solana. Sempre revise o código gerado quanto à eficiência de compute units, boas práticas de segurança como o uso de Program Derived Addresses (PDAs), e tratamento adequado de erros para chamadas RPC e falhas de transação.

Newsletter da Alchemy

Seja o primeiro a saber sobre lançamentos

Assine nossa newsletter

Receba as últimas atualizações de produtos e recursos da Alchemy

Mais de 80.000 inscritos

Ao inserir seu endereço de e-mail, você concorda em receber nossas comunicações de marketing e atualizações de produtos. Você reconhece que a Alchemy processa as informações que recebemos de acordo com nosso Aviso de Privacidade. Você pode cancelar a inscrição a qualquer momento.

Fundo da seção de artigos relacionados do post do blog

Como criar agentes de IA Solana em 2026

Por que Solana para agentes de IA?

Entendendo o stack de agentes de IA

O panorama dos frameworks de agentes

Solana Agent Kit (SendAI)

ElizaOS

GOAT toolkit (Crossmint)

Rig framework (Rust)

LangChain

Construindo seu primeiro agente Solana: passo a passo

Pré-requisitos

Configuração do projeto

Configuração do ambiente

Entendendo a arquitetura do nosso agente

O script do agente

Imports e configuração

Inicializando o agente

O loop de chat interativo

O script completo

Executando o agente

O que você construiu

Integrando a Jupiter para operações DeFi

Como a Jupiter funciona

Integração direta com a Jupiter

Servidor MCP da Jupiter

Arquitetura de segurança de wallet

A arquitetura de chave dupla

Proteção TEE

Boas práticas de segurança

Integração com o Model Context Protocol (MCP)

Servidor MCP da Solana

Construindo com o ElizaOS: exemplo de bot de Twitter

O que estamos construindo

Entendendo a arquitetura do ElizaOS

Configuração

Configuração do ambiente

Entendendo os arquivos de personagem

O arquivo de personagem completo

Inicie seu agente

O que acontece quando alguém tweeta

Estendendo o bot

Considerações de produção para bots sociais

Ferramentas de agente: CLI, Skills e MCP

Conclusão

Perguntas frequentes

Quais ferramentas vocês recomendam para construir agentes de IA na Solana?

Por que a Solana é preferida para desenvolvimento de agentes de IA?

Quais linguagens de programação são melhores para construir agentes de IA na Solana?

Como devo proteger a wallet do meu agente de IA?

Posso construir um agente de IA que opera no Twitter ou no Discord?

Como integro a Jupiter para trocas de tokens no meu agente?

O que é o Model Context Protocol (MCP) e como ele ajuda?

Quais são os erros comuns ao construir agentes de IA na Solana?

Newsletter da Alchemy

Assine nossa newsletter

Artigos relacionados

Glamsterdam: o guia completo para desenvolvedores de Ethereum

Em qual provedor de RPC você deve construir em Tóquio?

Arquitetando leituras Solana RPC para velocidade e confiabilidade líderes do setor