LangChain

pip install langchain-openai langchain-core

npm install @langchain/openai @langchain/core

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage
import json
import base64
from datetime import datetime, timedelta
from nacl.signing import SigningKey

# Load keypair and generate SIWx signature (see AI Agent Guide)
def generate_siwx_header(keypair_path, domain="beta.aimo.network"):
    with open(keypair_path) as f:
        keypair_data = json.load(f)
        secret_key = bytes(keypair_data[:32])
        signing_key = SigningKey(secret_key)
    
    issued_at = datetime.utcnow().isoformat() + "Z"
    expiration_time = (datetime.utcnow() + timedelta(minutes=5)).isoformat() + "Z"
    
    chain_id = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp"
    address = signing_key.verify_key.encode().hex()
    
    message = f"""{domain} wants you to sign in with your account:
{chain_id}:{address}

URI: https://{domain}
Version: 1
Chain ID: {chain_id}
Nonce: {int(datetime.utcnow().timestamp())}
Issued At: {issued_at}
Expiration Time: {expiration_time}"""
    
    signature = signing_key.sign(message.encode()).signature
    
    payload = {
        "message": message,
        "signature": base64.b58encode(signature).decode()
    }
    
    return base64.b64encode(json.dumps(payload).encode()).decode()

# Configure for AiMo Network
llm = ChatOpenAI(
    api_key="not-used",
    base_url="https://beta.aimo.network/api/v1",
    model="deepseek/deepseek-v3.2",
    default_headers={
        "Sign-In-With-X": generate_siwx_header("~/.config/aimo/keypair.json")
    }
)

# Simple chat
messages = [
    SystemMessage(content="You are a helpful assistant."),
    HumanMessage(content="Hello, how are you?")
]

response = llm.invoke(messages)
print(response.content)

import { ChatOpenAI } from "@langchain/openai";
import { HumanMessage, SystemMessage } from "@langchain/core/messages";
import * as ed25519 from "@noble/ed25519";
import * as fs from "fs";

// Load keypair and generate SIWx signature (see AI Agent Guide)
async function generateSiwxHeader(keypairPath, domain = "beta.aimo.network") {
  const keypairData = JSON.parse(fs.readFileSync(keypairPath, "utf-8"));
  const secretKey = new Uint8Array(keypairData.slice(0, 32));
  const publicKey = await ed25519.getPublicKeyAsync(secretKey);
  
  const issuedAt = new Date().toISOString();
  const expirationTime = new Date(Date.now() + 5 * 60 * 1000).toISOString();
  
  const chainId = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
  const address = Buffer.from(publicKey).toString("hex");
  
  const message = `${domain} wants you to sign in with your account:
${chainId}:${address}

URI: https://${domain}
Version: 1
Chain ID: ${chainId}
Nonce: ${Math.floor(Date.now() / 1000)}
Issued At: ${issuedAt}
Expiration Time: ${expirationTime}`;
  
  const signature = await ed25519.signAsync(Buffer.from(message), secretKey);
  
  const payload = {
    message,
    signature: Buffer.from(signature).toString("base64")
  };
  
  return Buffer.from(JSON.stringify(payload)).toString("base64");
}

// Configure for AiMo Network
const siwxHeader = await generateSiwxHeader("~/.config/aimo/keypair.json");

const llm = new ChatOpenAI({
  apiKey: "not-used",
  model: "deepseek/deepseek-v3.2",
  configuration: {
    baseURL: "https://beta.aimo.network/api/v1",
    defaultHeaders: {
      "Sign-In-With-X": siwxHeader
    }
  }
});

// Simple chat
const messages = [
  new SystemMessage("You are a helpful assistant."),
  new HumanMessage("Hello, how are you?")
];

const response = await llm.invoke(messages);
console.log(response.content);

from langchain_core.prompts import PromptTemplate
from langchain.chains import LLMChain

# Create a prompt template
template = """Question: {question}
Answer: Let's think step by step."""

prompt = PromptTemplate(
    template=template,
    input_variables=["question"]
)

# Create chain
chain = LLMChain(prompt=prompt, llm=llm)

# Use the chain
question = "What are the benefits of decentralized AI?"
result = chain.run(question)
print(result)

import { PromptTemplate } from "@langchain/core/prompts";
import { LLMChain } from "langchain/chains";

// Create a prompt template
const template = `Question: {question}
Answer: Let's think step by step.`;

const prompt = new PromptTemplate({
  template: template,
  inputVariables: ["question"]
});

// Create chain
const chain = new LLMChain({ llm: llm, prompt: prompt });

// Use the chain
const question = "What are the benefits of decentralized AI?";
const result = await chain.call({ question: question });
console.log(result.text);

# Streaming with LangChain
for chunk in llm.stream(messages):
    print(chunk.content, end="", flush=True)

// Streaming with LangChain
const stream = await llm.stream(messages);
for await (const chunk of stream) {
  process.stdout.write(chunk.content);
}