internet-court/internet-court-skill / vendored/sendaifun/solana-agent-kit
solana-agent-kit
VerifiedComprehensive guide for building AI agents that interact with Solana blockchain using SendAI's Solana Agent Kit. Covers 60+ actions, LangChain/Vercel AI integration, MCP server setup, and autonomous agent patterns.
| File | Kind | Size |
|---|---|---|
| LICENSE | other | 11.1 KB |
| SKILL.md | skill md | 15.0 KB |
| docs/custom-actions.md | markdown | 11.1 KB |
| docs/troubleshooting.md | markdown | 12.2 KB |
| examples/autonomous-agent/README.md | markdown | 16.4 KB |
| examples/langchain/README.md | markdown | 9.4 KB |
| examples/mcp-server/README.md | markdown | 6.6 KB |
| examples/vercel-ai/README.md | markdown | 8.9 KB |
| resources/actions-reference.md | markdown | 9.4 KB |
| templates/agent-template.ts | script | 11.2 KB |
examples/langchain/README.md
View on GitHub# LangChain Integration with Solana Agent Kit
Complete guide for integrating Solana Agent Kit with LangChain for building conversational AI agents.
## Setup
### Installation
```bash
npm install solana-agent-kit \
@solana-agent-kit/plugin-token \
@solana-agent-kit/plugin-nft \
@solana-agent-kit/plugin-defi \
@langchain/openai \
@langchain/core \
@langchain/langgraph \
dotenv \
bs58
```
### Environment Variables
```bash
# .env
OPENAI_API_KEY=sk-...
RPC_URL=https://api.devnet.solana.com
SOLANA_PRIVATE_KEY=your_base58_encoded_key
```
## Basic Chat Agent
```typescript
// langchain-agent.ts
import { SolanaAgentKit, createSolanaTools } from "solana-agent-kit";
import TokenPlugin from "@solana-agent-kit/plugin-token";
import DefiPlugin from "@solana-agent-kit/plugin-defi";
import { ChatOpenAI } from "@langchain/openai";
import { createReactAgent } from "@langchain/langgraph/prebuilt";
import { MemorySaver } from "@langchain/langgraph";
import { HumanMessage, AIMessage } from "@langchain/core/messages";
import { Keypair } from "@solana/web3.js";
import bs58 from "bs58";
import * as readline from "readline";
import "dotenv/config";
// Initialize wallet
function createWallet(): Keypair {
const privateKey = process.env.SOLANA_PRIVATE_KEY!;
// Handle both formats
try {
// Try base58 first
return Keypair.fromSecretKey(bs58.decode(privateKey));
} catch {
// Try JSON array
const keyArray = JSON.parse(privateKey);
return Keypair.fromSecretKey(new Uint8Array(keyArray));
}
}
// Initialize agent
async function initializeAgent() {
const keypair = createWallet();
// Create LLM
const llm = new ChatOpenAI({
modelName: "gpt-4-turbo-preview",
temperature: 0.7,
});
// Create Solana Agent Kit
const solanaKit = new SolanaAgentKit(
bs58.encode(keypair.secretKey),
process.env.RPC_URL!,
{ OPENAI_API_KEY: process.env.OPENAI_API_KEY! }
)
.use(TokenPlugin)
.use(DefiPlugin);
// Create LangChain tools from Solana Agent Kit
const tools = createSolanaTools(solanaKit);
// Create memory for conversation persistence
const memory = new MemorySaver();
// Create ReAct agent
const agent = createReactAgent({
llm,
tools,
checkpointSaver: memory,
});
return { agent, solanaKit };
}
// Interactive chat loop
async function runChat() {
const { agent } = await initializeAgent();
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout,
});
const config = { configurable: { thread_id: "solana-chat-1" } };
console.log("Solana Agent ready! Type your message (or 'quit' to exit)");
console.log("Example: 'What is my wallet address?'");
console.log("Example: 'Swap 0.1 SOL for USDC'");
console.log("");
const askQuestion = () => {
rl.question("You: ", async (input) => {
if (input.toLowerCase() === "quit") {
console.log("Goodbye!");
rl.close();
return;
}
try {
const stream = await agent.stream(
{ messages: [new HumanMessage(input)] },
config
);
process.stdout.write("Agent: ");
for await (const chunk of stream) {
if ("agent" in chunk) {
const content = chunk.agent.messages[0].content;
if (typeof content === "string") {
process.stdout.write(content);
}
} else if ("tools" in chunk) {
// Tool execution - optionally log
console.log("\n[Executing tool...]");
}
}
console.log("\n");
} catch (error) {
console.error("Error:", error);
}
askQuestion();
});
};
askQuestion();
}
runChat();
```
## Agent with Custom System Prompt
```typescript
import { ChatPromptTemplate, MessagesPlaceholder } from "@langchain/core/prompts";
async function createAgentWithSystemPrompt() {
const llm = new ChatOpenAI({
modelName: "gpt-4-turbo-preview",
temperature: 0.7,
});
const solanaKit = new SolanaAgentKit(wallet, rpcUrl, options)
.use(TokenPlugin)
.use(DefiPlugin);
const tools = createSolanaTools(solanaKit);
// Custom system prompt
const systemPrompt = `You are a helpful Solana blockchain assistant.
You can help users with:
- Checking wallet balances
- Swapping tokens via Jupiter
- Deploying new tokens
- Managing NFTs
Always confirm large transactions before executing.
When swapping tokens, warn about slippage.
Never reveal private keys.
Current network: ${process.env.RPC_URL?.includes("devnet") ? "Devnet" : "Mainnet"}`;
const prompt = ChatPromptTemplate.fromMessages([
["system", systemPrompt],
new MessagesPlaceholder("messages"),
new MessagesPlaceholder("agent_scratchpad"),
]);
const agent = createReactAgent({
llm,
tools,
messageModifier: prompt,
});
return agent;
}
```
## Multi-Turn Conversation with History
```typescript
import { BufferMemory, ChatMessageHistory } from "langchain/memory";
async function createAgentWithHistory() {
const llm = new ChatOpenAI({ modelName: "gpt-4-turbo-preview" });
const tools = createSolanaTools(solanaKit);
// Create persistent memory
const memory = new MemorySaver();
const agent = createReactAgent({
llm,
tools,
checkpointSaver: memory,
});
// Each conversation has a unique thread_id
async function chat(threadId: string, message: string) {
const config = { configurable: { thread_id: threadId } };
const response = await agent.invoke(
{ messages: [new HumanMessage(message)] },
config
);
return response.messages[response.messages.length - 1].content;
}
// Example conversation
const thread = "user-123";
await chat(thread, "What is my wallet address?");
await chat(thread, "Check my SOL balance");
await chat(thread, "Now swap 0.1 SOL for USDC");
// Agent remembers context from previous messages
}
```
## Streaming Responses
```typescript
async function streamingChat(agent: any, message: string) {
const config = { configurable: { thread_id: "streaming-thread" } };
const stream = await agent.stream(
{ messages: [new HumanMessage(message)] },
config
);
const events: string[] = [];
for await (const chunk of stream) {
if ("agent" in chunk) {
// Agent's response
const content = chunk.agent.messages[0].content;
process.stdout.write(content);
events.push(`agent: ${content}`);
} else if ("tools" in chunk) {
// Tool execution
const toolResult = chunk.tools.messages[0];
console.log(`\n[Tool: ${toolResult.name}]`);
events.push(`tool: ${toolResult.name}`);
}
}
return events;
}
```
## Tool Filtering (Reduce Hallucinations)
```typescript
// Only load specific tools to reduce confusion
function createFilteredTools(solanaKit: SolanaAgentKit) {
const allTools = createSolanaTools(solanaKit);
// Filter to only swap and balance tools
const allowedTools = ["trade", "getBalance", "getWalletAddress"];
return allTools.filter((tool) => allowedTools.includes(tool.name));
}
// Usage
const agent = createReactAgent({
llm,
tools: createFilteredTools(solanaKit), // Fewer tools = less confusion
});
```
## Error Handling
```typescript
async function robustChat(agent: any, message: string) {
const config = { configurable: { thread_id: "robust-thread" } };
try {
const response = await agent.invoke(
{ messages: [new HumanMessage(message)] },
config
);
const lastMessage = response.messages[response.messages.length - 1];
// Check for tool errors
if (lastMessage.additional_kwargs?.tool_calls) {
for (const call of lastMessage.additional_kwargs.tool_calls) {
if (call.error) {
console.error(`Tool error: ${call.error}`);
}
}
}
return lastMessage.content;
} catch (error) {
if (error.message.includes("rate limit")) {
console.log("Rate limited, waiting...");
await new Promise((r) => setTimeout(r, 5000));
return robustChat(agent, message);
}
if (error.message.includes("insufficient funds")) {
return "Transaction failed: insufficient funds in wallet";
}
throw error;
}
}
```
## Production Considerations
### 1. Rate Limiting
```typescript
import Bottleneck from "bottleneck";
const limiter = new Bottleneck({
minTime: 1000, // 1 request per second
maxConcurrent: 1,
});
const rateLimitedChat = limiter.wrap(async (message: string) => {
return agent.invoke({ messages: [new HumanMessage(message)] }, config);
});
```
### 2. Transaction Confirmation
```typescript
// Add confirmation step for transactions
const systemPrompt = `Before executing any transaction that transfers tokens or SOL:
1. Summarize what the transaction will do
2. Ask the user to confirm with "yes" or "no"
3. Only proceed if user confirms`;
```
### 3. Logging
```typescript
import { CallbackManager } from "@langchain/core/callbacks/manager";
const callbacks = new CallbackManager();
callbacks.addHandler({
handleToolStart: (tool, input) => {
console.log(`[TOOL START] ${tool.name}:`, input);
},
handleToolEnd: (output) => {
console.log(`[TOOL END]`, output);
},
handleLLMStart: () => {
console.log("[LLM START]");
},
});
const agent = createReactAgent({
llm,
tools,
callbacks,
});
```
## Common Commands
Test these commands with your agent:
```
"What is my wallet address?"
"Check my SOL balance"
"Get my USDC balance"
"Swap 0.1 SOL for USDC"
"What tokens do I have?"
"Request devnet SOL" (devnet only)
"Create a new token called TestCoin with symbol TC"
```
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |