Build Autonomous AI Agents

import { Agent, Tool } from '@moltbuilds/core';

export class MyCustomAgent extends Agent {
  name = 'custom-agent';
  description = 'My custom agent description';
  
  tools: Tool[] = [
    new WebScraperTool(),
    new AlertTool(),
  ];

  async onMessage(message: string) {
    // Handle incoming messages
    const response = await this.think(message);
    return response;
  }
}

import { defineConfig } from '@moltbuilds/core';

export default defineConfig({
  agent: {
    name: 'my-alpha-hunter',
    model: 'gpt-4o',
    temperature: 0.7,
  },
  
  memory: {
    type: 'vector',
    provider: 'pinecone',
    contextWindow: 32000,
  },
  
  tools: [
    'web-scraper',
    'sentiment-analyzer',
    'twitter-api',
  ],
  
  security: {
    rateLimit: 100,
    contentFilter: 'medium',
    sandboxed: true,
  },
});

# LLM Providers
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...

# Integrations
TWITTER_API_KEY=...
TWITTER_API_SECRET=...
DISCORD_BOT_TOKEN=...

# Database
PINECONE_API_KEY=...
PINECONE_ENVIRONMENT=us-east-1

import { VectorMemory } from '@moltbuilds/memory';

const memory = new VectorMemory({
  provider: 'pinecone',
  index: 'agent-memory',
  embedModel: 'text-embedding-3-small',
  topK: 5,
});

// Store a memory
await memory.store('User prefers technical analysis over fundamentals');

// Retrieve relevant memories
const memories = await memory.retrieve('What trading style does the user prefer?');

import { Tool, ToolInput } from '@moltbuilds/core';

export class PriceFetcherTool extends Tool {
  name = 'price-fetcher';
  description = 'Fetches current token prices from CoinGecko';
  
  schema = {
    token: { type: 'string', required: true },
  };

  async execute(input: ToolInput) {
    const response = await fetch(
      `https://api.coingecko.com/api/v3/simple/price?ids=${input.token}&vs_currencies=usd`
    );
    return response.json();
  }
}

import { DiscordAdapter } from '@moltbuilds/adapters';

const discord = new DiscordAdapter({
  token: process.env.DISCORD_BOT_TOKEN,
  intents: ['Guilds', 'GuildMessages', 'DirectMessages'],
});

// Register slash commands
discord.registerCommand({
  name: 'ask',
  description: 'Ask the AI agent a question',
  handler: async (interaction) => {
    const response = await agent.chat(interaction.options.getString('question'));
    await interaction.reply(response);
  }
});

discord.start();

import { TelegramAdapter } from '@moltbuilds/adapters';

const telegram = new TelegramAdapter({
  token: process.env.TELEGRAM_BOT_TOKEN,
  allowedChats: ['@mychannel', -1001234567890],
});

telegram.on('message', async (ctx) => {
  const response = await agent.chat(ctx.message.text);
  await ctx.reply(response);
});

telegram.launch();

import { SolanaWallet } from '@moltbuilds/blockchain';

const wallet = new SolanaWallet({
  rpcUrl: process.env.HELIUS_RPC_URL,
  privateKey: process.env.WALLET_PRIVATE_KEY,
});

// Get balance
const balance = await wallet.getBalance();
console.log(`Balance: ${balance} SOL`);

// Swap tokens via Jupiter
const tx = await wallet.swap({
  inputMint: 'So11111111111111111111111111111111111111112', // SOL
  outputMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', // USDC
  amount: 0.1,
  slippage: 0.5,
});

console.log(`Swap tx: ${tx.signature}`);

import { DuneClient, BirdeyeClient } from '@moltbuilds/data';

// Query Dune Analytics
const dune = new DuneClient(process.env.DUNE_API_KEY);
const whales = await dune.query(3156732); // Top SOL holders

// Get token price from Birdeye
const birdeye = new BirdeyeClient(process.env.BIRDEYE_API_KEY);
const price = await birdeye.getPrice('So11111111111111111111111111111111111111112');

https://api.moltbuilds.dev/v1

curl -X POST https://api.moltbuilds.dev/v1/agents \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "my-agent", "template": "alpha-hunter"}'

curl -X POST https://api.moltbuilds.dev/v1/agents \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-alpha-hunter",
    "template": "alpha-hunter",
    "model": "gpt-4o",
    "tools": ["web-scraper", "twitter-api"],
    "config": {
      "temperature": 0.7,
      "maxTokens": 4096
    }
  }'

{
  "id": "agt_abc123",
  "name": "my-alpha-hunter",
  "status": "created",
  "template": "alpha-hunter",
  "model": "gpt-4o",
  "tools": ["web-scraper", "twitter-api"],
  "createdAt": "2024-01-15T10:30:00Z"
}

curl -X POST https://api.moltbuilds.dev/v1/agents/agt_abc123/chat \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "message": "Find the top trending tokens on Solana today",
    "stream": false
  }'

curl -X POST https://api.moltbuilds.dev/v1/tools/web-scraper/invoke \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com",
    "selector": ".main-content",
    "format": "markdown"
  }'

{
  "success": true,
  "tool": "web-scraper",
  "result": {
    "content": "# Page Title\n\nExtracted content here...",
    "metadata": {
      "url": "https://example.com",
      "scrapedAt": "2024-01-15T10:30:00Z",
      "contentLength": 2450
    }
  },
  "executionTime": 1234
}

curl -X POST https://api.moltbuilds.dev/v1/tools/register \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "price-alert",
    "description": "Set price alerts for tokens",
    "schema": {
      "token": { "type": "string", "required": true },
      "targetPrice": { "type": "number", "required": true },
      "direction": { "type": "string", "enum": ["above", "below"] }
    },
    "webhookUrl": "https://your-server.com/webhook/price-alert"
  }'

import { Agent, WebScraperTool, TwitterTool, AlertTool } from '@moltbuilds/core';
import { TelegramAdapter } from '@moltbuilds/adapters';

const agent = new Agent({
  name: 'alpha-hunter',
  model: 'gpt-4o',
  systemPrompt: `You are an alpha hunter that finds early crypto opportunities.
    Monitor social signals, analyze sentiment, and alert on high-conviction plays.`,
  tools: [
    new WebScraperTool(),
    new TwitterTool({ apiKey: process.env.TWITTER_API_KEY }),
    new AlertTool({ webhook: process.env.ALERT_WEBHOOK }),
  ],
});

// Schedule hourly scans
agent.schedule('0 * * * *', async () => {
  const signals = await agent.chat('Scan Twitter for trending crypto tokens and analyze sentiment');
  console.log(signals);
});

// Connect to Telegram
const telegram = new TelegramAdapter({ token: process.env.TELEGRAM_BOT_TOKEN });
telegram.connect(agent);
telegram.launch();

import { Agent } from '@moltbuilds/core';
import { SolanaWallet, JupiterSwap } from '@moltbuilds/blockchain';

const wallet = new SolanaWallet({
  rpcUrl: process.env.HELIUS_RPC_URL,
  privateKey: process.env.WALLET_PRIVATE_KEY,
});

const jupiter = new JupiterSwap(wallet);

const agent = new Agent({
  name: 'dca-bot',
  model: 'gpt-4o',
  tools: [wallet, jupiter],
});

// DCA: Buy $10 of SOL every day at 9am
agent.schedule('0 9 * * *', async () => {
  const result = await jupiter.swap({
    inputMint: 'USDC',
    outputMint: 'SOL',
    amount: 10,
    slippage: 0.5,
  });
  console.log(`DCA executed: ${result.signature}`);
});

agent.start();

import { Agent, ImageGenTool, TwitterTool } from '@moltbuilds/core';

const agent = new Agent({
  name: 'content-creator',
  model: 'gpt-4o',
  systemPrompt: `You are a crypto content creator. Create engaging threads,
    memes, and educational content about DeFi and blockchain.`,
  tools: [
    new ImageGenTool({ provider: 'dall-e-3' }),
    new TwitterTool({ 
      apiKey: process.env.TWITTER_API_KEY,
      apiSecret: process.env.TWITTER_API_SECRET,
    }),
  ],
});

// Generate and post a thread
const thread = await agent.chat(`
  Create a Twitter thread explaining liquid staking on Solana.
  Make it educational but engaging. Include relevant emojis.
  Generate a header image for the thread.
`);

console.log(thread);