Core AgentKit LangChain Extension

LangChain integration for Core AgentKit, enabling seamless use of Core blockchain actions within LangChain workflows.

Installation

npm install core-agentkit-langchain

Usage

Method 1: Using LLM with Tools (Recommended)

import {
  AgentKit,
  CoreWalletProvider,
  coreActionProvider,
} from "core-agentkit";
import { getLangChainTools } from "core-agentkit-langchain";
import { ChatOpenAI } from "@langchain/openai";
// or use any other LLM like ChatGoogleGenerativeAI

// Create wallet provider
const walletProvider = new CoreWalletProvider(
  process.env.PRIVATE_KEY!,
  "core-testnet"
);

// Create AgentKit instance
const agentKit = AgentKit.from(walletProvider, [coreActionProvider()]);

// Get LangChain tools
const tools = await getLangChainTools(agentKit);

// Create LLM with tools
const llm = new ChatOpenAI({ model: "gpt-4", temperature: 0 });
const llmWithTools = llm.bindTools(tools);

// Use the LLM with tools
const result = await llmWithTools.invoke([
  {
    role: "user",
    content: "Transfer 0.1 CORE to 0x742d35Cc6634C0532925a3b8D81C3f83C7A84C5e",
  },
]);

// Handle tool calls
if (result && result.tool_calls && result.tool_calls.length > 0) {
  console.log("Executing tools:", result.tool_calls);

  const toolMessages = await Promise.all(
    result.tool_calls.map(async (toolCall: any) => {
      const tool = tools.find((t: any) => t.name === toolCall.name);
      if (!tool) {
        return {
          content: `Tool ${toolCall.name} not found.`,
          tool_call_id: toolCall.id,
        };
      }

      try {
        const output = await tool.invoke(toolCall.args);
        return {
          content: typeof output === "string" ? output : JSON.stringify(output),
          tool_call_id: toolCall.id,
        };
      } catch (error) {
        return {
          content: `Error executing tool ${toolCall.name}: ${(error as Error).message}`,
          tool_call_id: toolCall.id,
        };
      }
    })
  );

  console.log("Tool execution results:", toolMessages);
}

Method 2: Using LangGraph Agents

import {
  AgentKit,
  CoreWalletProvider,
  coreActionProvider,
} from "core-agentkit";
import { getLangChainTools } from "core-agentkit-langchain";
import { ChatOpenAI } from "@langchain/openai";
import { createReactAgent } from "@langchain/langgraph/prebuilt";

// Create wallet provider
const walletProvider = new CoreWalletProvider(
  process.env.PRIVATE_KEY!,
  "core-testnet"
);

// Create AgentKit instance
const agentKit = AgentKit.from(walletProvider, [coreActionProvider()]);

// Get LangChain tools
const tools = await getLangChainTools(agentKit);

// Create agent
const model = new ChatOpenAI({ temperature: 0 });
const agent = createReactAgent({ llm: model, tools });

// Use agent
const result = await agent.invoke({
  messages: [{ role: "user", content: "Check my CORE balance" }],
});

Available Tools

When you convert Core AgentKit actions to LangChain tools, you get access to:

• get_balance: Get CORE balance for an address
• transfer: Transfer CORE tokens to another address
• get_token_balance: Get ERC-20 token balance for an address
• transfer_token: Transfer ERC-20 tokens to another address
• stake: Stake CORE tokens with a validator
• unstake: Unstake CORE tokens from a validator

API Reference

getLangChainTools(agentKit: AgentKit): Promise<StructuredTool[]>

Converts all actions from a Core AgentKit instance into LangChain tools.

createLangChainTool(action: Action): StructuredTool

Converts a single Core AgentKit action into a LangChain tool.

License

MIT