Cómo crear agentes de IA en Solana en 2026

Última actualización: 26 de enero de 202622 min de lectura

Fila de rostros de agentes de IA que ilustra el desarrollo de agentes de IA en Solana

Los agentes de IA están transformando la forma en que interactuamos con la infraestructura blockchain. Estos programas autónomos pueden ejecutar transacciones, gestionar portafolios, acuñar NFTs e interactuar con protocolos DeFi, todo mediante comandos en lenguaje natural. Muy lejos de la UX temprana de las criptomonedas.

Solana se ha convertido en la blockchain líder para el desarrollo de agentes de IA, representando el 77% del volumen de transacciones x402 en diciembre de 2025, al combinar finalidad en menos de un segundo, costos de transacción insignificantes y un ecosistema maduro de frameworks diseñados específicamente para aplicaciones agénticas.

Esta guía recorre el proceso de construir agentes de IA listos para producción en Solana, desde elegir el framework adecuado hasta implementar arquitecturas de wallet seguras. Ya sea que estés construyendo un bot de trading, un asistente personal onchain o un gestor DeFi autónomo, aquí encontrarás la base técnica que necesitas.

¿Por qué Solana para agentes de IA?

Los agentes de IA tienen el potencial de transformar la actividad onchain y habilitar casos de uso completamente nuevos, lo que lleva a una pregunta importante para los desarrolladores que quieren comenzar: ¿en qué blockchain se construyen agentes de IA?

La respuesta, cada vez más, es Solana. Un solo agente que monitorea mercados, ejecuta operaciones y rebalancea portafolios puede enviar cientos de transacciones al día. En Ethereum mainnet, ese ritmo operativo podría costar miles de dólares en gas. En Solana, cuesta centavos. Pero el costo es solo el punto de partida; la arquitectura de Solana se alinea con los requisitos de los agentes de maneras que van mucho más allá de las comisiones:

La velocidad importa para la autonomía: Los agentes necesitan reaccionar a las condiciones del mercado, las solicitudes de los usuarios y los eventos onchain en tiempo real. Los bloques de 400ms y la finalidad en menos de un segundo de Solana permiten ciclos de retroalimentación ajustados. Los agentes operan en ciclos: razonar sobre qué hacer, ejecutar una acción, observar el resultado y volver a razonar. Cada paso de "observación" requiere esperar la confirmación de la transacción. En una cadena con tiempos de bloque de 12 segundos, un flujo de trabajo de 3 pasos implica más de 36 segundos de espera inactiva entre decisiones, y el agente pierde el ciclo de retroalimentación ajustado que hace que la operación autónoma se sienta responsiva. En Solana, ese mismo flujo de trabajo se confirma en menos de 2 segundos, lo que permite que los agentes razonen y actúen casi en tiempo real. Esta es la diferencia entre un agente que se siente como un trabajo por lotes que enviaste y uno que se siente como un colaborador que trabaja junto a ti.
Las comisiones predecibles permiten planificar: Los agentes necesitan presupuestar sus operaciones. El modelo de comisiones de Solana, aproximadamente $0.00025 por transacción, permite construir agentes que pueden operar indefinidamente con capital mínimo. Las comisiones prioritarias durante la congestión siguen siendo razonables en comparación con las subastas de gas de otras cadenas.
Composabilidad nativa de programas: Los programas de Solana pueden llamar a otros programas de forma atómica dentro de una sola transacción. Un agente puede intercambiar tokens en Jupiter, hacer staking del resultado en Marinade y acuñar un NFT de recibo, todo en una sola operación atómica. Esta composabilidad es lo que diferencia a los agentes de Solana de los flujos de trabajo secuenciales torpes. Cuando un agente puede agrupar varias operaciones en una sola transacción atómica, por ejemplo, intercambiar tokens, proveer liquidez y hacer staking de la posición LP, se ejecuta más rápido (una confirmación en vez de tres), cuesta menos (una comisión base en vez de tres) y requiere código más simple (sin manejo de errores entre pasos). Para los usuarios, la diferencia es abismal: pídele al agente que "optimice mi yield" y simplemente lo hace en segundos, en lugar de guiarte por un proceso de varios pasos con avisos de confirmación en cada etapa.
Impulso del ecosistema: El ecosistema de agentes de IA en Solana ha crecido explosivamente desde finales de 2024. Solana Agent Kit de SendAI, ElizaOS (antes ai16z), el GOAT toolkit de Crossmint y frameworks nativos de Rust como Rig han creado un entorno de desarrollo rico. Jupiter procesa el 90% del volumen de los agregadores de DEX de Solana con APIs diseñadas para acceso programático, lo que facilita enormemente que los agentes se conecten y utilicen estos datos.

Entendiendo el stack de agentes de IA

Antes de entrar en el código, demos un vistazo rápido a las capas del stack de agentes de IA, lo que puede ayudarte a entender qué herramientas deberías usar para una tarea dada. El stack de agentes de IA se puede resumir en 4 capas:

Large Language Models (LLMs): Los LLMs forman la base de cualquier agente de IA. Los modelos más recientes como Claude Opus 4.5, GPT-5.2 o Gemeni 2.5 Pro proporcionan la comprensión del lenguaje natural y las capacidades de razonamiento. Procesan las solicitudes de los usuarios, interpretan los datos blockchain ingeridos y deciden qué acciones tomar. El LLM es el "cerebro" que hace que un agente sea inteligente en lugar de simplemente un script.
Frameworks de agentes: Los frameworks se ubican sobre los LLMs y manejan la orquestación de cómo funcionará el agente. Administran el historial de conversación, mantienen la "personalidad" del agente mediante system prompts, coordinan múltiples herramientas e integran plataformas externas como Twitter, Discord o Telegram. ElizaOS es el ejemplo líder; combina integración de LLM, gestión de memoria y clientes multiplataforma en un framework unificado.
Toolkits de blockchain: Los toolkits le dan a los agentes la capacidad de interactuar realmente con Solana. El Solana Agent Kit, el GOAT toolkit y bibliotecas similares exponen operaciones de blockchain como "herramientas" que los LLMs pueden invocar. Cuando un usuario dice "intercambia 10 SOL por USDC", el toolkit traduce eso en llamadas a la API de Jupiter, construcción de transacciones y envío.

El panorama de frameworks de agentes

Con la base conceptual cubierta, hablemos de los cuatro frameworks principales que dominarán el desarrollo de agentes de IA en Solana en 2026.

Solana Agent Kit (SendAI)

El Solana Agent Kit es el camino más directo para construir agentes que interactúan con el ecosistema de Solana. Desarrollado por SendAI, proporciona más de 60 acciones preconstruidas que cubren operaciones con tokens, acuñación de NFTs, interacciones DeFi y más. El kit se integra limpiamente con LangChain, Vercel AI SDK y otros frameworks populares de desarrollo de IA.

La arquitectura modular de plugins de SendAI te permite instalar solo lo que necesitas. El plugin de tokens maneja transferencias e intercambios de tokens SPL. El plugin de NFT gestiona operaciones de Metaplex. El plugin DeFi se integra con Jupiter, Raydium y otros protocolos. Esta modularidad mantiene los despliegues livianos.

Así es como se ve la inicialización de este framework. Primero, creas una wallet, instancias el agente con tus claves de RPC y API, y luego encadenas los plugins que necesitas:

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: Desarrolladores que quieren prototipado rápido con cobertura integral de Solana. El kit abstrae la mayor parte de la complejidad blockchain mientras sigue siendo lo suficientemente flexible para uso en producción.

ElizaOS

ElizaOS evolucionó del proyecto ai16z hasta convertirse en un sistema operativo de agentes completo. Está diseñado para agentes autónomos que mantienen personalidades persistentes entre plataformas: bots de Twitter, asistentes de Discord y canales de Telegram. El framework maneja la memoria, las definiciones de personaje y el despliegue multiplataforma.

Los agentes en ElizaOS se definen a través de archivos JSON de personaje que especifican personalidad, acciones disponibles y parámetros de comportamiento. El plugin de Solana proporciona capacidades de blockchain, y el framework gestiona la complejidad de mantener un comportamiento coherente del agente a través de las interacciones.

Comenzar es sencillo con la 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

La configuración real ocurre en tu archivo de personaje. Aquí es donde defines en qué plataformas opera tu agente, qué proveedor de LLM usar y qué capacidades de 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 sociales que necesitan una identidad persistente entre plataformas. Si estás construyendo un bot de Twitter o un asistente de Discord con capacidades de Solana, ElizaOS es la elección natural.

GOAT toolkit (Crossmint)

GOAT (Great Onchain Agent Toolkit) adopta un enfoque diferente. Está diseñado como un adaptador universal entre agentes de IA y cualquier aplicación blockchain. Mientras que el Solana Agent Kit se enfoca en operaciones específicas de Solana, GOAT proporciona una interfaz unificada en más de 30 cadenas, incluyendo Solana, redes EVM y otras.

El verdadero poder de GOAT está en la amplitud de su integración. Más de 200 plugins cubren protocolos desde Jupiter y Orca en Solana hasta Uniswap y Aave en Ethereum. Si estás construyendo agentes que necesitan operar en múltiples cadenas, GOAT elimina la necesidad de implementaciones específicas por cadena.

El patrón de inicialización es similar al de Solana Agent Kit. Primero inicializas una wallet, seleccionas tus plugins y generas herramientas para tu framework de IA. Aquí hay una configuración de Solana con integración de 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 multichain y aplicaciones que necesitan integrarse con protocolos DeFi específicos. El ecosistema de plugins de GOAT no tiene igual en cuanto a cobertura de protocolos.

Framework Rig (Rust)

Para aplicaciones donde el rendimiento es crítico, bots de trading de alta frecuencia, estrategias MEV, operaciones sensibles a la latencia, Rig proporciona un framework de agentes de IA nativo de Rust. Combinado con Listen.rs para la integración con Solana, ofrece el camino de menor latencia desde la decisión del LLM hasta la ejecución onchain.

Rig aprovecha el sistema de tipos de Rust para la corrección en tiempo de compilación y sus características de rendimiento para operaciones de sub-milisegundo. El rig-onchain-kit proporciona integración con Solana, y Listen.rs agrega monitoreo de transacciones y envío de bundles de Jito para transacciones protegidas contra MEV.

La API es limpia e idiomática en Rust. Creas un cliente, configuras un agente con un system prompt y empiezas a prompear:

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: Aplicaciones donde el rendimiento es crítico y la latencia importa. Si estás construyendo infraestructura de trading o necesitas integración directa con el ecosistema nativo de Rust de Solana, Rig es la elección.

LangChain

LangChain es el framework más ampliamente adoptado para construir aplicaciones impulsadas por LLMs. Aunque no es específico de blockchain, su abstracción de herramientas y arquitectura de agentes lo hacen una opción natural para el desarrollo en Solana. El Solana Agent Kit ofrece integración de primera clase con LangChain, permitiéndote aprovechar el ecosistema maduro de LangChain mientras accedes a las capacidades onchain de Solana.

La fortaleza de LangChain es la composabilidad, lo que permite a los desarrolladores encadenar prompts, herramientas, sistemas de memoria y mecanismos de recuperación en flujos de trabajo de agentes complejos. El framework maneja la gestión de conversaciones, la selección de herramientas y el parseo de salidas. Para agentes de Solana, esto significa que puedes combinar acciones onchain con fuentes de datos off-chain, pipelines de RAG y razonamiento de varios pasos.

La integración con Solana Agent Kit es fluida. Inicializas tu agente y luego usas el helper createLangchainTools para generar herramientas compatibles con LangChain a partir de tus acciones de 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" }]
});

LangChain también brilla cuando necesitas combinar operaciones de Solana con datos externos. Puedes agregar herramientas de búsqueda web, retrievers de bases de datos o integraciones de API personalizadas junto con tus herramientas de blockchain. El agente decide qué herramientas usar según la tarea.

Ideal para: Desarrolladores que ya trabajan en el ecosistema de LangChain, o aplicaciones que necesitan combinar operaciones de Solana con cadenas de razonamiento complejas, RAG o fuentes de datos externas. Si tu agente necesita más que solo interacciones con blockchain, LangChain proporciona la capa de orquestación.

Construyendo tu primer agente de Solana: paso a paso

Ahora que hemos cubierto la teoría fundamental, construyamos un agente de IA funcional en Solana usando el Solana Agent Kit y LangChain. Al final de esta sección, tendrás un agente que puede verificar balances, ejecutar intercambios y acuñar NFTs de recibo financiero, todo mediante comandos en lenguaje natural.

Construiremos esto de manera incremental, explicando cada pieza a medida que avanzamos.

Requisitos previos

Antes de comenzar, asegúrate de tener:

Node.js v23+: El Solana Agent Kit requiere funciones modernas de Node. Verifica tu versión con node --version. Si necesitas actualizar, nvm hace esto fácil:

bash

Copied

nvm install 23
nvm use 23

Una wallet de Solana: Necesitarás un keypair con algo de SOL de devnet para pruebas. Generaremos uno si no lo tienes. - Claves de API: OpenAI (para el LLM) y opcionalmente un proveedor de RPC dedicado como Alchemy

Configuración del proyecto

Comienza creando un nuevo directorio e inicializando tu proyecto:

bash

Copied

mkdir solana-agent
cd solana-agent
pnpm init

Ahora instala las dependencias. Cada paquete cumple un propósito específico:

bash

Copied

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

Esto es lo que hace cada dependencia:

solana-agent-kit: El toolkit central que proporciona acciones de Solana como herramientas compatibles con LLM
@langchain/core: Abstracciones base para mensajes, prompts e interfaces de herramientas
@langchain/openai: Integración de OpenAI para LangChain (GPT-4 como nuestro motor de razonamiento)
@langchain/langgraph: Proporciona el patrón de agente ReAct—el bucle en el que el LLM razona sobre qué herramienta usar, la usa, observa el resultado y decide qué hacer a continuación
dotenv: Carga variables de entorno desde un archivo .env
bs58: Codificación/decodificación Base58 para claves privadas de Solana

Configuración del entorno

Crea un archivo .env en la raíz de tu proyecto. Esto mantiene las credenciales sensibles fuera de tu 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]

Una nota sobre el formato de la clave privada: los keypairs de Solana son arreglos de 64 bytes. El archivo .env almacena esto como un arreglo JSON tipo \[123,45,67,...\]. Si necesitas generar un keypair nuevo para pruebas, usa:

bash

Copied

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

Esto crea una dirección vanity que comienza con "ai" (útil para identificar la wallet de tu agente). La salida incluye el keypair como un arreglo de bytes que puedes pegar en tu .env.

Importante: Nunca uses un keypair con fondos reales para desarrollo. Siempre prueba primero en devnet.

Entendiendo la arquitectura de nuestro agente

Antes de escribir código, entendamos qué estamos construyendo. Nuestro agente tiene tres componentes principales:

El LLM (GPT-5.2): El "cerebro" que entiende el lenguaje natural, razona sobre qué acciones tomar y genera respuestas
Las herramientas (Solana Agent Kit): Funciones que el LLM puede invocar—verificar balance, intercambiar tokens, acuñar NFTs, etc.
El bucle del agente (LangGraph ReAct): LangchainReAct es una implementación de la arquitectura de agente Reasoning and Acting (ReAct) usando el framework LangGraph. Este patrón de orquestación conecta el LLM y las herramientas. Cuando envías un mensaje, el agente recibe tu entrada → decide si se necesita una herramienta → llama a la herramienta → observa el resultado → decide si se necesitan más herramientas → genera una respuesta

Este es el patrón ReAct (Reasoning + Acting). El LLM no solo responde; razona sobre qué acciones tomar, las toma e incorpora los resultados en su respuesta.

El script del agente

Ahora construyamos agent.ts. Lo iremos viendo sección por sección.

Importaciones y configuración

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

Las importaciones se dividen en tres categorías: Solana Agent Kit para operaciones blockchain, LangChain para orquestación de IA, y utilidades de Node para variables de entorno y entrada del usuario.

Inicializando el agente

La función initializeAgent configura todos los componentes:

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

Estamos usando GPT-5.2 como motor de razonamiento. El temperature de 0.7 balancea la creatividad con la consistencia; valores más bajos hacen las respuestas más determinísticas, valores más altos las hacen más variadas. Para un agente que necesita tomar decisiones confiables sobre transacciones financieras, podrías bajar esto a 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);

Este fragmento convierte la clave privada del formato de arreglo JSON en nuestro .env a la cadena base58 que el Solana Agent Kit espera. El camino de conversión: cadena JSON → arreglo de JavaScript → Uint8Array → cadena 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! }
);

La instancia de SolanaAgentKit conecta tu wallet a la red de Solana. Recibe tres argumentos: la clave privada (para firmar transacciones), la URL de RPC (para la comunicación con la red) y opciones de configuración (incluyendo la clave de OpenAI para cualquier operación interna de IA).

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

Aquí es donde ocurre la magia. createSolanaTools transforma las capacidades del Solana Agent Kit en herramientas compatibles con LangChain. Cada herramienta tiene un nombre, una descripción y un esquema de entrada que el LLM usa para entender qué puede hacer y cómo invocarla. Por debajo, estás obteniendo herramientas como get\_balance, transfer, swap, deploy\_token, mint\_nft, y docenas más.

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

La memoria permite que el agente mantenga contexto a través de múltiples turnos. Sin ella, cada mensaje se trataría de forma aislada; el agente no recordaría que acabas de preguntar sobre tu balance cuando sigues con "intercambia la mitad".

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

Finalmente, ensamblamos todo en un agente ReAct. Esto crea el bucle de razonamiento: el LLM recibe la entrada, decide qué herramienta (si alguna) usar, la ejecuta, observa el resultado y, o bien toma otra acción, o responde al usuario.

El bucle de chat interactivo

La segunda función crea una interfaz de terminal para chatear con tu agente:

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

El thread\_id identifica esta conversación con fines de memoria. Si reinicias el script con el mismo ID de hilo, el agente (en teoría) recordaría el contexto previo. IDs de hilo diferentes significan contextos de conversación diferentes.

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

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

Configuración estándar de readline de Node.js para entrada/salida de terminal que crea una interfaz readline que captura tu entrada de teclado desde la terminal (stdin) y escribe las respuestas del agente de vuelta en tu pantalla (stdout). Es la forma más sencilla de construir un chat interactivo de línea de comandos sin incorporar dependencias adicionales.

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

Cuando escribes un mensaje, se envuelve en un HumanMessage y se envía al agente. Usamos stream en lugar de invoke para obtener salida en tiempo real mientras el agente piensa y actúa.

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

El bucle de streaming maneja dos tipos de fragmentos: fragmentos agent (el razonamiento y las respuestas del LLM) y fragmentos tools (resultados de ejecuciones de herramientas). Esto te permite ver qué está pasando en tiempo real—el agente pensando, invocando herramientas y formulando su respuesta.

El script completo

Aquí está el agent.ts completo como referencia:

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

Ejecutando el agente

Ejecútalo con tsx (ejecución de TypeScript):

bash

Copied

npx tsx agent.ts

Deberías ver el mensaje de "listo". Ahora prueba algunos 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/...

Qué pasa por debajo: cuando preguntas sobre tu balance, el LLM reconoce que esto requiere la herramienta get\_balance, la invoca con los parámetros correctos, recibe el resultado y lo incorpora en una respuesta en lenguaje natural. Para intercambios, identifica la herramienta swap, parsea tu intención (0.1 SOL → USDC), ejecuta el intercambio en Jupiter y confirma la transacción.

Lo que has construido

Ahora tienes un agente de IA de Solana funcional con:

Comprensión de lenguaje natural vía GPT-5.2
Más de 60 operaciones de Solana disponibles como herramientas
Memoria de conversación para interacciones de varios turnos
Respuestas de streaming en tiempo real

Esta es una base de desarrollo. El despliegue en producción requiere consideraciones adicionales—seguridad de wallet, fiabilidad de transacciones, limitación de tasa—que cubriremos en secciones posteriores.

Integrando Jupiter para operaciones DeFi

Jupiter es el agregador de DEX dominante de Solana, enrutando más del 90% del volumen de agregadores. Cuando tu agente necesita intercambiar tokens, Jupiter encuentra la mejor ruta entre docenas de DEXs—Raydium, Orca, Phoenix, y más—para obtener el precio óptimo.

El Solana Agent Kit incluye integración con Jupiter desde el primer momento. Cuando le pides a tu agente que "intercambie 1 SOL por USDC", ya está usando Jupiter por debajo. Pero a veces necesitas más control: tolerancias de slippage personalizadas, preferencias de enrutamiento específicas o integración directa con tu propio pipeline de transacciones.

Cómo funciona Jupiter

La API de Jupiter sigue un patrón de cotización-luego-intercambio:

Cotización: Envías el token de entrada, el token de salida y el monto. Jupiter consulta todos los DEXs disponibles y devuelve la mejor ruta con los montos de salida esperados.
Intercambio: Devuelves la cotización junto con la dirección de tu wallet. Jupiter construye una transacción que ejecuta la ruta óptima.
Firma y envío: Firmas la transacción y la envías a la red.

Este proceso de dos pasos te permite mostrar a los usuarios qué recibirán antes de comprometerse con la operación.

Integración directa con Jupiter

Aquí hay una función de intercambio completa con explicación paso a paso:

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

Comenzamos con las importaciones estándar de Solana web3.js y el cliente de la API de Jupiter. Las direcciones mint son los identificadores únicos de los tokens en Solana. SOL usa una dirección especial "wrapped" para compatibilidad con 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();

El cliente de Jupiter se conecta a su API alojada. No se requiere clave de API para uso básico, aunque aplican límites de tasa.

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

La solicitud de cotización especifica lo que estás intercambiando. slippageBps es la tolerancia de slippage en puntos básicos; 50 significa 0.5%. Si el precio se mueve más que esto entre la cotización y la ejecución, la transacción falla en lugar de darte una peor tasa.

La respuesta de la cotización incluye el monto de salida esperado, la ruta (qué DEXs se usarán) y el impacto de precio. Para agentes en producción, querrías verificar estos valores antes de continuar.

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

La solicitud de intercambio toma tu cotización y la dirección de tu wallet y devuelve una transacción serializada. wrapAndUnwrapSol: true maneja una particularidad de Solana: los DEXs trabajan con "SOL wrapped" (un token SPL), pero los usuarios tienen SOL nativo. Este flag agrega instrucciones para envolver antes y desenvolver después del intercambio automáticamente.

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

Jupiter devuelve la transacción como una cadena codificada en base64. La deserializamos en un objeto de transacción adecuado y la firmamos con nuestro keypair. Nota que estamos usando VersionedTransaction,—Jupiter usa el formato de transacción más nuevo de Solana, que soporta tablas de búsqueda de direcciones para rutas más complejas.

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

return signature;
}

Finalmente, enviamos la transacción firmada a la red y esperamos la confirmación. La firma es un identificador único que puedes usar para buscar la transacción en exploradores como Solscan.

Servidor MCP de Jupiter

Para asistentes de IA que soportan el Model Context Protocol (como Claude Desktop o Cursor), Jupiter ofrece un servidor MCP. Esto le da a tu asistente de IA acceso directo a las capacidades de Jupiter a través de una interfaz estandarizada.

Configúralo en tu configuración de MCP:

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

Una vez configurado, Claude puede ejecutar intercambios de Jupiter directamente a través de lenguaje natural: "Intercambia 0.5 SOL por USDC" se convierte en una transacción onchain real. Esto es particularmente poderoso para prototipado rápido: puedes construir y probar flujos de trabajo DeFi a través de la conversación antes de comprometerte con el código.

Arquitectura de seguridad de wallets

Un agente de IA con autoridad de firma es un objetivo de alto valor. Un agente comprometido puede vaciar su wallet instantáneamente. La arquitectura de seguridad debe equilibrar la autonomía con la protección.

La arquitectura de doble clave

El estándar emergente para wallets de agentes seguras usa una arquitectura de doble clave con wallets de contrato inteligente:

Wallet de contrato inteligente: Una sola wallet (usando patrones ERC-4337 en EVM o el protocolo Squads en Solana) que puede tener múltiples firmantes autorizados.

Clave de propietario: La tiene el usuario y otorga el control definitivo. Con ella, puedes agregar/quitar claves de agente, retirar fondos y anular acciones del agente.

Clave de agente: Desplegada dentro de un Trusted Execution Environment (TEE), registrada en la wallet de contrato inteligente con permisos limitados. Con esta clave, el agente solo puede realizar operaciones autorizadas.

La implementación de Crossmint hace esto sencillo. Creas una wallet custodiada vinculada a una identidad de usuario, y el agente opera dentro de los permisos que defines:

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

Protección TEE

Los Trusted Execution Environments proporcionan aislamiento a nivel de hardware para las claves de agente. Plataformas como Phala Network y Turnkey ofrecen infraestructura TEE diseñada específicamente para agentes de IA.

Turnkey proporciona acceso a wallets controlado por políticas. En lugar de exponer claves privadas, los agentes reciben credenciales de API con alcance limitado que solo pueden realizar operaciones autorizadas. Defines políticas que limitan los tipos de transacción, los montos y las tasas—luego el agente opera dentro de esos límites:

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`

Phala Network proporciona infraestructura TEE descentralizada. Los agentes desplegados en Phala se ejecutan en enclaves aislados donde ni siquiera el sistema anfitrión puede acceder a las claves privadas. El despliegue está basado en contenedores:

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

Buenas prácticas de seguridad

Varios principios deben guiar la arquitectura de seguridad de los agentes:

Minimiza la exposición de claves: Las claves privadas nunca deben aparecer en logs, mensajes de error o memoria accesible. Usa variables de entorno e infraestructura segura de gestión de claves.
Implementa límites de transacción: Los agentes deben tener tamaños máximos de transacción, límites de gasto diario y límites de tasa. Un agente comprometido con autoridad ilimitada puede causar daño ilimitado.
Usa wallets separadas: Los agentes en producción deben usar wallets dedicadas con solo los fondos necesarios para las operaciones. Nunca conectes un agente a una wallet que contenga activos significativos.
Monitorea la actividad del agente: Registra todas las transacciones del agente e implementa alertas para patrones inusuales. El monitoreo automatizado puede detectar compromisos antes de que ocurra un daño significativo.
Prueba primero en devnet: Siempre desarrolla y prueba los agentes en devnet antes del despliegue en mainnet. La URL de RPC típicamente es el único cambio necesario para cambiar de red.

Integración del Model Context Protocol (MCP)

El Model Context Protocol estandariza cómo los asistentes de IA interactúan con herramientas externas. Para el desarrollo en Solana, los servidores MCP permiten que Claude, Cursor y otras herramientas de IA interactúen directamente con la blockchain.

Servidor MCP de Solana

El servidor MCP de Solana de SendAI proporciona herramientas de blockchain a cualquier asistente de IA compatible con MCP:

bash

Copied

# Install globally
npm install -g solana-mcp

# Or run directly

npx solana-mcp

Las herramientas disponibles en el servidor MCP incluyen:

GET\_ASSET: Obtener información de tokens/NFTs
GET\_BALANCE: Verificar balances de wallet
TRANSFER: Enviar SOL o tokens SPL
SWAP: Ejecutar intercambios en Jupiter
DEPLOY\_TOKEN: Crear nuevos tokens SPL
MINT\_NFT: Acuñar NFTs vía Metaplex

Construyendo con ElizaOS: ejemplo de bot de Twitter

Hasta ahora, hemos construido un agente funcional que puede razonar, ejecutar transacciones de Solana y mantener contexto de conversación, todo desde la terminal. Ahora llevemos esas mismas capacidades y desplegémoslas donde los usuarios realmente están: Twitter, usando ElizaOS.

ElizaOS brilla para agentes sociales, bots que mantienen personalidades persistentes entre plataformas. Construyamos un bot de Twitter.

Qué vamos a construir

Este bot hará lo siguiente:

Monitorear Twitter en busca de menciones que pregunten sobre tokens, protocolos o condiciones de mercado
Obtener datos onchain: precios de tokens, volumen de operaciones, profundidad de liquidez, movimientos de ballenas
Analizar y resumir los datos en inglés claro
Mantener una personalidad de "analista" consistente en todas las interacciones

ElizaOS maneja la orquestación compleja: vigilar las menciones, mantener el contexto de la conversación, decidir cuándo consultar datos onchain y generar respuestas que coincidan con la personalidad definida.

Entendiendo la arquitectura de ElizaOS

Antes de entrar en el código, entendamos cómo ElizaOS estructura un agente:

Clientes conectan el agente a plataformas—Twitter, Discord, Telegram o acceso directo a la API. Cada cliente maneja la autenticación específica de la plataforma, el sondeo de mensajes y el formateo de respuestas.

Plugins proporcionan capacidades. El plugin de Solana le da a tu agente herramientas para leer datos onchain, consultas de tokens e historial de transacciones. Otros plugins podrían agregar generación de imágenes, búsqueda web o acciones personalizadas.

Archivos de personaje definen la personalidad y el comportamiento a través de JSON estructurado. Esto incluye biografía, estilo de comunicación, conversaciones de ejemplo y parámetros de comportamiento.

La memoria persiste a través de las conversaciones. ElizaOS registra con quién ha hablado el agente, qué preguntas han hecho y el contexto relevante para interacciones futuras.

Configuración

Comienza clonando el repositorio de ElizaOS:

bash

Copied

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

ElizaOS es un monorepo que contiene el framework central, todos los plugins oficiales y las implementaciones de clientes. Trabajaremos dentro de esta estructura en lugar de crear un proyecto separado.

Instala las dependencias y compila:

bash

Copied

pnpm install --no-frozen-lockfile
pnpm build

El flag --no-frozen-lockfile permite que pnpm actualice el lockfile si es necesario. El paso de compilación compila TypeScript y prepara todos los paquetes.

Configuración del entorno

Crea un archivo .env en la raíz del proyecto. ElizaOS lee este archivo para todas las credenciales y configuraciones:

bash

Copied

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

La autenticación de Twitter usa las credenciales de la cuenta de tu bot. ElizaOS inicia sesión y mantiene una sesión para sondear menciones y publicar respuestas. Asegúrate de usar una cuenta de bot dedicada—no querrás que tu Twitter personal ejecute un agente automatizado.

bash

Copied

# LLM provider
OPENAI_API_KEY=your_openai_key

El proveedor del modelo impulsa el razonamiento del agente. ElizaOS soporta múltiples proveedores (OpenAI, Anthropic, modelos locales), pero OpenAI es el más sencillo para comenzar.

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 un bot analista, no necesitas una clave privada—estamos leyendo datos, no firmando transacciones. Usa un RPC de mainnet ya que quieres datos de mercado reales, no tokens de prueba de devnet. Un proveedor de RPC dedicado como Alchemy te da límites de tasa más altos y datos más confiables que el endpoint público.

Nota de seguridad: Aunque este bot solo lee datos, protege tus claves de API. Los límites de tasa de tu proveedor de RPC están vinculados a estas credenciales.

Entendiendo los archivos de personaje

Los archivos de personaje son el corazón de un agente de ElizaOS. Definen no solo lo que el agente puede hacer, sino quién es. Construyamos uno pieza por pieza.

Crea characters/solana-analyst.character.json:

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

El encabezado define lo básico:

name: Cómo se identifica el agente
clients: A qué plataformas conectarse. Agregar "discord" aquí habilitaría la integración con Discord sin código adicional.
modelProvider: Qué LLM usar para el razonamiento
plugins: Capacidades a habilitar. El plugin de Solana proporciona consultas de datos de tokens, feeds de precios y análisis 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 es un arreglo de declaraciones que definen la autodescripción del agente. ElizaOS usa estas cuando el agente necesita presentarse o responder preguntas tipo "¿quién eres?". Múltiples entradas agregan variedad—el agente podría tomar diferentes líneas de biografía según el contexto.

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 proporciona contexto de fondo al que el agente puede hacer referencia. Esto no se expone directamente a los usuarios, pero influye en cómo el agente entiende su propio propósito e historia. Piensa en esto como el trasfondo interno del 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 son ejemplos few-shot que enseñan al agente cómo responder. Cada ejemplo es un arreglo de conversación que muestra la entrada del usuario y la respuesta esperada del agente. Nota cómo los ejemplos establecen el tono: basado en datos, con números específicos, contexto accionable, sin relleno.

Agrega más ejemplos para cubrir casos límite: ¿qué pasa si alguien pregunta sobre un token que no existe? ¿Qué pasa si quieren un análisis comparativo? ¿Qué pasa si preguntan sobre un token estafa? Cuantos más escenarios cubras, más consistente será el comportamiento del 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 patrones de comunicación en diferentes contextos:

all: Se aplica a cada respuesta
chat: Específico para mensajes directos y respuestas
post: Para publicaciones originales que crea el agente

Estas son palabras clave descriptivas que influyen en el tono del LLM. "evita el hype" es importante para un analista financiero—quieres un análisis mesurado, no "SOL A LA LUNA 🚀". "proporciona contexto para los números" asegura que el agente no solo escupa precios, sino que explique qué significan.

El archivo de personaje completo

Aquí está la definición completa del personaje:

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

Lanza tu agente

Inicia el agente con tu archivo de personaje:

bash

Copied

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

Verás logs mientras ElizaOS:

Carga la definición del personaje
Inicializa el proveedor de OpenAI
Se conecta a Twitter
Carga el plugin de Solana
Comienza a sondear menciones

Qué pasa cuando alguien tuitea

Cuando un usuario tuitea "@TuBot ¿cuál es el volumen de BONK hoy?", este es el flujo:

El cliente de Twitter detecta la mención mediante sondeo
El manejador de mensajes parsea el tuit y crea un contexto de conversación
El LLM recibe el mensaje junto con la definición del personaje, la biografía y los ejemplos
La selección de herramienta reconoce esto como una consulta de datos y selecciona la acción de plugin de Solana apropiada
La ejecución del plugin obtiene datos del token desde el RPC y agrega precios desde Jupiter
La generación de respuesta crea una respuesta que contextualiza los datos crudos
El cliente de Twitter publica la respuesta como un hilo

El agente mantiene memoria de esta interacción. Si el mismo usuario pregunta "¿cómo se compara eso con ayer?" una hora después, el agente puede referenciar la conversación anterior y proporcionar un análisis comparativo.

Extendiendo el bot

El enfoque de archivo de personaje hace que la iteración sea rápida. ¿Quieres agregar soporte para Discord?

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

Agrega variables de entorno para Discord, reinicia, y tu agente ahora opera en ambas plataformas con la misma personalidad.

¿Quieres agregar alertas proactivas? Puedes configurar el agente para publicar cuando detecte actividad inusual:

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

Ahora el agente monitoreará de forma independiente la actividad onchain y tuiteará cuando ocurra algo notable—sin requerir un prompt del usuario.

Consideraciones de producción para bots sociales

Twitter tiene límites de tasa y políticas de automatización. Para el despliegue en producción:

Limitación de tasa: No respondas a cada mención instantáneamente. Agrega retrasos que imiten tiempos de respuesta humanos.
Políticas de contenido: Las reglas de automatización de Twitter requieren una divulgación clara de que la cuenta es un bot. Ponlo en tu biografía.
Precisión de datos: Tu bot está proporcionando información financiera. Agrega descargos de responsabilidad, cita las fuentes de datos y sé claro sobre las limitaciones. "No es asesoría financiera" no es solo protección legal—es responsable.
Manejo de errores: Las llamadas RPC pueden fallar, los datos pueden quedar desactualizados, los tokens pueden ser deslistados. Maneja esto con elegancia en lugar de publicar errores públicamente.
Monitoreo: Rastrea qué consultas maneja el bot y qué respuestas genera. Quieres visibilidad sobre lo que está diciendo, especialmente cuando los mercados son volátiles.

Herramientas para agentes: CLI, Skills y MCP

Los frameworks manejan la orquestación. Alchemy para agentes cubre la capa de infraestructura.

Instala Alchemy Skills, conecta el servidor MCP y autentica el 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

Consulta desde la 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

Conclusión

Ahora has construido tu primer agente de IA de Solana. Si hay algo que deberías recordar de este tutorial, es que la infraestructura para construir agentes de IA en Solana ha madurado dramáticamente.

La cadena es rápida. Los frameworks están listos. La pregunta es qué construirás con ellos.

¿Listo para empezar? Alchemy proporciona la infraestructura de RPC que impulsa a los principales agentes y frameworks de IA en Solana. Ya sea que necesites endpoints de baja latencia, APIs mejoradas para operaciones con tokens, o soporte multichain para agentes multiplataforma, la plataforma de Alchemy te da la base para construir agentes de IA de nivel producción que pueden operar a escala.

Preguntas frecuentes

¿Qué herramientas recomiendan para construir agentes de IA en Solana?

Sugerimos usar Solana Agent Kit, ElizaOS, GOAT toolkit y el framework Rig dependiendo de tu caso de uso. Solana Agent Kit ofrece prototipado rápido con más de 60 acciones preconstruidas, ElizaOS destaca en agentes sociales en varias plataformas, GOAT proporciona soporte multichain y Rig ofrece desarrollo nativo de Rust para aplicaciones donde el rendimiento es crítico.

¿Por qué se prefiere Solana para el desarrollo de agentes de IA?

Los bloques de 400ms y la finalidad en menos de un segundo de Solana permiten ciclos de retroalimentación en tiempo real, lo que permite que los agentes razonen, actúen y observen resultados rápidamente. Las comisiones de transacción promedian $0.00025, lo que hace que las operaciones de alta frecuencia sean económicas, y la composabilidad nativa de programas permite que los agentes ejecuten operaciones complejas de varios pasos en transacciones atómicas únicas.

¿Qué lenguajes de programación son mejores para construir agentes de IA en Solana?

TypeScript con Solana Agent Kit o LangChain es ideal para el desarrollo rápido y la integración amplia con el ecosistema. Para aplicaciones donde el rendimiento es crítico, como el trading de alta frecuencia o estrategias MEV, Rust con el framework Rig ofrece el camino de menor latencia desde la decisión del LLM hasta la ejecución onchain.

¿Cómo debería asegurar la wallet de mi agente de IA?

Usa una arquitectura de doble clave con wallets de contrato inteligente donde la clave de propietario otorga el control definitivo y la clave de agente opera dentro de un Trusted Execution Environment (TEE) con permisos limitados. Nunca expongas claves privadas en logs, implementa límites de transacción, usa wallets separadas con fondos mínimos, y siempre prueba primero en devnet.

¿Puedo construir un agente de IA que opere en Twitter o Discord?

Sí, ElizaOS permite que los agentes mantengan personalidades persistentes en Twitter, Discord, Telegram y otras plataformas simultáneamente. Defines el comportamiento del agente a través de un archivo JSON de personaje, y ElizaOS maneja la autenticación específica de la plataforma, el sondeo de mensajes y el formateo de respuestas.

¿Cómo integro Jupiter para intercambios de tokens en mi agente?

El Solana Agent Kit incluye integración con Jupiter desde el primer momento a través de acciones de intercambio preconstruidas. Para implementaciones personalizadas, usa el patrón de API de cotización-luego-intercambio de Jupiter: solicita una cotización con tu par de trading, construye la transacción de intercambio con la dirección de tu wallet, luego firma y envía la transacción versionada.

¿Qué es el Model Context Protocol (MCP) y cómo ayuda?

MCP estandariza cómo los asistentes de IA interactúan con herramientas externas. El servidor MCP de Solana permite que Claude, Cursor y otras herramientas de IA compatibles con MCP ejecuten operaciones de blockchain directamente mediante lenguaje natural, incluyendo verificaciones de balance, transferencias de tokens, intercambios y acuñación de NFTs.

¿Cuáles son los errores comunes al construir agentes de IA en Solana?

El código generado por IA puede producir actualizaciones de cuenta secuenciales en lugar de procesamiento paralelo, o ignorar optimizaciones específicas de Solana. Siempre revisa el código generado en busca de eficiencia de unidades de cómputo, buenas prácticas de seguridad como el uso de Program Derived Addresses (PDAs), y un manejo adecuado de errores para llamadas RPC y fallos de transacción.

Boletín de Alchemy

Entérate primero de los lanzamientos

Suscríbete a nuestro boletín

Recibe las últimas actualizaciones de productos y recursos de Alchemy

Más de 80,000 suscriptores

Al ingresar tu correo electrónico, aceptas recibir nuestras comunicaciones de marketing y actualizaciones de productos. Reconoces que Alchemy procesa la información que recibimos de acuerdo con nuestro Aviso de Privacidad. Puedes cancelar tu suscripción en cualquier momento.

Fondo de artículos relacionados de la publicación del blog

Cómo crear agentes de IA en Solana en 2026

¿Por qué Solana para agentes de IA?

Entendiendo el stack de agentes de IA

El panorama de frameworks de agentes

Solana Agent Kit (SendAI)

ElizaOS

GOAT toolkit (Crossmint)

Framework Rig (Rust)

LangChain

Construyendo tu primer agente de Solana: paso a paso

Requisitos previos

Configuración del proyecto

Configuración del entorno

Entendiendo la arquitectura de nuestro agente

El script del agente

Importaciones y configuración

Inicializando el agente

El bucle de chat interactivo

El script completo

Ejecutando el agente

Lo que has construido

Integrando Jupiter para operaciones DeFi

Cómo funciona Jupiter

Integración directa con Jupiter

Servidor MCP de Jupiter

Arquitectura de seguridad de wallets

La arquitectura de doble clave

Protección TEE

Buenas prácticas de seguridad

Integración del Model Context Protocol (MCP)

Servidor MCP de Solana

Construyendo con ElizaOS: ejemplo de bot de Twitter

Qué vamos a construir

Entendiendo la arquitectura de ElizaOS

Configuración

Configuración del entorno

Entendiendo los archivos de personaje

El archivo de personaje completo

Lanza tu agente

Qué pasa cuando alguien tuitea

Extendiendo el bot

Consideraciones de producción para bots sociales

Herramientas para agentes: CLI, Skills y MCP

Conclusión

Preguntas frecuentes

¿Qué herramientas recomiendan para construir agentes de IA en Solana?

¿Por qué se prefiere Solana para el desarrollo de agentes de IA?

¿Qué lenguajes de programación son mejores para construir agentes de IA en Solana?

¿Cómo debería asegurar la wallet de mi agente de IA?

¿Puedo construir un agente de IA que opere en Twitter o Discord?

¿Cómo integro Jupiter para intercambios de tokens en mi agente?

¿Qué es el Model Context Protocol (MCP) y cómo ayuda?

¿Cuáles son los errores comunes al construir agentes de IA en Solana?

Boletín de Alchemy

Suscríbete a nuestro boletín

Artículos relacionados

Glamsterdam: la guía completa para desarrolladores de Ethereum

¿Con qué proveedor de RPC deberías construir en Tokio?

Diseño de lecturas RPC de Solana para velocidad y confiabilidad líderes en la industria