Eliza

"Create a bucket for me named 'project-logs'"
"Add object 'data.json' to bucket 'research'"
"Get object 'meeting-notes.txt' from bucket 'meetings'"
"Check my Recall credit balance"
"Buy 2 Recall credits"

export const recallCotProvider: Provider = {
  get: async (
    _runtime: IAgentRuntime,
    message: Memory,
    _state?: State
  ): Promise<Error | string> => {
    if (!process.env.RECALL_BUCKET_ALIAS) {
      elizaLogger.error("RECALL_BUCKET_ALIAS is not set");
    }
    try {
      const recallService = _runtime.services.get("recall" as ServiceType) as RecallService;
      const res = await recallService.retrieveOrderedChainOfThoughtLogs(
        process.env.RECALL_BUCKET_ALIAS
      );
      return JSON.stringify(res, null, 2);
    } catch (error) {
      return error instanceof Error ? error.message : "Unable to get storage provider";
    }
  },
};

class RecallService implements IService {
  private wallet: Wallet;
  private sdk: SDK;
  private client: Client;
  private chainLiteral: ChainLiteral = "testnet";
  private syncInterval: NodeJS.Timeout | null = null;
  private batchSize = 4; // In KB
 
  constructor() {
    // Initialize with environment variables
    this.chainLiteral = (process.env.RECALL_NETWORK as ChainLiteral) || "testnet";
    this.batchSize = Number(process.env.RECALL_BATCH_SIZE) || 4;
 
    // Set up SDK and client
    this.wallet = new Wallet(process.env.RECALL_PRIVATE_KEY || "");
    this.sdk = new SDK();
    this.client = this.sdk.createClient({
      chain: this.chainLiteral,
      wallet: this.wallet,
    });
  }
 
  // Bucket management methods
  async getOrCreateBucket(bucketAlias: string): Promise<any> {
    try {
      // Try to find existing bucket
      const bucket = await this.client.getBucketByAlias(bucketAlias);
      if (bucket) {
        return { bucket: bucket.id, exists: true };
      }
 
      // Create new bucket if not found
      const newBucket = await this.client.createBucket(bucketAlias);
      return { bucket: newBucket.id, exists: false };
    } catch (error) {
      // Handle errors
      throw error;
    }
  }
 
  // Object storage methods
  async addObject(bucketId: string, key: string, data: string, metadata?: any): Promise<any> {
    try {
      // Add object to bucket
      const result = await this.client.addObject(bucketId, key, data, metadata);
      return result;
    } catch (error) {
      // Handle errors
      throw error;
    }
  }
 
  // Object retrieval methods
  async getObject(bucketId: string, key: string): Promise<any> {
    try {
      // Get object from bucket
      const result = await this.client.getObject(bucketId, key);
      return result;
    } catch (error) {
      // Handle errors
      throw error;
    }
  }
 
  // Chain-of-thought logging methods
  async syncLogsToRecall(bucketAlias: string): Promise<void> {
    // Sync logs from local database to Recall bucket
    // Implementation details...
  }
 
  // Start periodic sync
  startPeriodicSync(bucketAlias: string, intervalMs = 120000): void {
    if (this.syncInterval) {
      clearInterval(this.syncInterval);
    }
 
    this.syncInterval = setInterval(() => {
      this.syncLogsToRecall(bucketAlias).catch((error) => {
        elizaLogger.error("Failed to sync logs to Recall:", error);
      });
    }, intervalMs);
  }
}

RECALL_SYNC_INTERVAL="120000"  # Sync interval in milliseconds (default: 2 minutes)
RECALL_BATCH_SIZE="4"          # Batch size in kilobytes (default: 4KB)
RECALL_COT_LOG_PREFIX="cot/"   # Prefix for chain-of-thought logs

{
  "id": "recall-agent",
  "name": "Recall Agent",
  "description": "An AI assistant with Recall storage capabilities",
  "instructions": "You are an AI assistant with access to Recall storage. You can create buckets, store data, and retrieve information from previous conversations.",
  "model": {
    "provider": "openai",
    "model": "gpt-4",
    "temperature": 0.7,
    "systemPrompt": "You are an AI assistant with access to Recall storage. Use this capability to remember information across sessions."
  },
  "tools": [],
  "providers": [
    {
      "name": "recall_cot",
      "description": "Provides chain-of-thought reasoning from previous interactions",
      "schema": {
        "type": "string"
      }
    }
  ],
  "services": [
    {
      "name": "recall",
      "config": {
        "bucketAlias": "agent-memory"
      }
    }
  ]
}

pnpm start --characters="path/to/custom-agent.character.json"

// Modify this object to customize action triggers
const ACTION_PATTERNS = {
  CREATE_BUCKET: [
    /create\s+(?:a\s+)?bucket\s+(?:for\s+me\s+)?(?:named|called)\s+["'](.+?)["']/i,
    /make\s+(?:a\s+)?(?:new\s+)?bucket\s+(?:named|called)\s+["'](.+?)["']/i,
  ],
  LIST_BUCKETS: [
    /(?:get|show|list)\s+(?:a\s+list\s+of\s+)?my\s+(?:recall\s+)?buckets/i,
    /what\s+buckets\s+do\s+I\s+have/i,
  ],
  // Additional patterns...
};

async function retrieveOrderedChainOfThoughtLogs(bucketAlias: string): Promise<any[]> {
  try {
    // Get or create bucket
    const { bucket } = await this.getOrCreateBucket(bucketAlias);
 
    // Query objects with the CoT prefix
    const objects = await this.client.queryObjects(bucket, {
      prefix: process.env.RECALL_COT_LOG_PREFIX || "cot/",
    });
 
    if (!objects || objects.objects.length === 0) {
      return [];
    }
 
    // Get and parse objects
    const logs = await Promise.all(
      objects.objects.map(async (obj: any) => {
        const data = await this.client.getObject(bucket, obj.key);
        return { ...JSON.parse(data.value), timestamp: obj.created };
      })
    );
 
    // Sort by timestamp and return
    return logs.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
  } catch (error) {
    elizaLogger.error("Failed to retrieve chain-of-thought logs:", error);
    return [];
  }
}