Drop AI Agents into Any Node.js App. Four Lines of Code.

const { CeoAI } = require('@ceo-ai/sdk');  
  
const ceo = new CeoAI({ apiKey: process.env.CEO_API_KEY });  
  
const { response } = await ceo.promptAndWait('Summarize our sales this quarter');  
console.log(response);

const { CeoAI } = require('@ceo-ai/sdk');  
  
const ceo = new CeoAI({ apiKey: process.env.CEO_API_KEY });  
  
// Submit the prompt  
const submission = await ceo.prompt('Generate a detailed report');  
console.log('Presigned URL:', submission.presignedUrl);  
  
// Store submission.presignedUrl in your database  
// ...  
  
// Later (even in a different process), retrieve the result:  
const result = await ceo.pollForResult(storedPresignedUrl);  
console.log(result);

const { CeoAI } = require('@ceo-ai/sdk');  
  
const ceo = new CeoAI({ apiKey: process.env.CEO_API_KEY });  
  
// First message  
const first = await ceo.promptAndWait('What was our Q4 revenue?');  
console.log(first.response);  
  
// Follow-up with context  
const second = await ceo.promptAndWait('How does that compare to Q3?', {  
    conversationHistory: [  
        { role: 'user', content: 'What was our Q4 revenue?' },  
        { role: 'assistant', content: JSON.stringify(first.response) }  
    ]  
});  
console.log(second.response);

const { response } = await ceo.promptAndWait('What is 2 + 2?', {  
    ragMode: false  
});

const { response } = await ceo.promptAndWait('Complex analysis...', {  
    pollInterval: 3000,  
    pollTimeout: 300000, // 5 minutes  
    onPoll: (attempt, elapsed) => {  
        const seconds = Math.round(elapsed / 1000);  
        console.log(`⏳ Waiting for response... ${seconds}s (attempt ${attempt})`);  
    }  
});

const { CeoAI } = require('@ceo-ai/sdk');  
const fs = require('fs');  
  
const ceo = new CeoAI({ apiKey: process.env.CEO_API_KEY });  
  
// Train on a single document  
const content = fs.readFileSync('./docs/product-guide.md', 'utf8');  
const result = await ceo.addRag(content, 'product-guide.md');  
console.log(`Added ${result.memoriesAdded} memories (${result.creditsDeducted} credits)`);  
  
// Train on an entire directory of files  
const path = require('path');  
  
async function trainOnDirectory(dirPath) {  
    const files = fs.readdirSync(dirPath);  
      
    for (const file of files) {  
        const filePath = path.join(dirPath, file);  
        const stat = fs.statSync(filePath);  
          
        if (stat.isFile() && stat.size <= 4 * 1024 * 1024) { // Max 4MB    
            const content = fs.readFileSync(filePath, 'utf8');    
            const result = await ceo.addRag(content, file);    
            console.log(`✓ ${file} (${result.totalChunks} chunks, ${result.creditsDeducted} credits)`);    
        }    
    }    
}    
    
await trainOnDirectory('./knowledge-base');

const { CeoAI, CeoAPIError } = require('@ceo-ai/sdk');  
  
const ceo = new CeoAI({ apiKey: process.env.CEO_API_KEY });  
  
try {  
    const { response } = await ceo.promptAndWait('What was our Q4 revenue?');  
    console.log(response);  
  
} catch (error) {  
    if (error instanceof CeoAPIError) {  
        switch (true) {  
            case error.isAuthError:  
                console.error('❌ Invalid or expired API key');  
                console.error('   Get a new key at https://app.ceo.ai/apikeys');  
                break;  
  
            case error.isInsufficientCredits:  
                console.error('❌ Insufficient credits');  
                console.error(`   Required: ${error.details?.requiredCredits}`);  
                console.error(`   Available: ${error.details?.availableCredits}`);  
                console.error('   Add credits at https://app.ceo.ai/usercredits');  
                break;  
  
            case error.isTimeout:  
                console.error('❌ Request timed out');  
                console.error('   Try increasing pollTimeout');  
                break;  
  
            case error.isRateLimited:  
                console.error('❌ Rate limited. Please wait and try again.');  
                break;  
  
            default:  
                console.error(`❌ API error (${error.statusCode}): ${error.message}`);  
        }  
    } else {  
        console.error('❌ Unexpected error:', error.message);  
    }  
}

const { CeoAI } = require('@ceo-ai/sdk');    
    
const ceo = new CeoAI({ apiKey: process.env.CEO_API_KEY });    
    
const questions = [    
    'What was Q1 revenue?',    
    'What was Q2 revenue?',    
    'What was Q3 revenue?',    
    'What was Q4 revenue?'    
];    
    
// Submit all prompts concurrently    
const submissions = await Promise.all(    
    questions.map(q => ceo.prompt(q))    
);    
    
console.log(`Submitted ${submissions.length} prompts`);    
    
// Wait a bit, then collect all results    
await new Promise(r => setTimeout(r, 10000));    
    
const results = await Promise.all(    
    submissions.map(s => ceo.pollForResult(s.presignedUrl, {    
        timeout: 60000    
    }))    
);    
    
results.forEach((result, i) => {    
    console.log(`\n--- ${questions[i]} ---`);    
    console.log(result);    
});

const { CeoAI } = require('@ceo-ai/sdk');    
const fs = require('fs');    
const path = require('path');    
    
const ceo = new CeoAI({ apiKey: process.env.CEO_API_KEY });    
    
/**    
 * Train an agent on all supported files in a directory    
 */    
async function trainAgent(directory, options = {}) {    
    const { recursive = false, extensions = ['md', 'txt', 'json'] } = options;    
        
    const results = { succeeded: 0, failed: 0, totalCredits: 0 };    
        
    async function processDir(dir) {    
        const entries = fs.readdirSync(dir, { withFileTypes: true });    
            
        for (const entry of entries) {    
            const fullPath = path.join(dir, entry.name);    
                
            if (entry.isDirectory() && recursive) {    
                if (!entry.name.startsWith('.') && entry.name !== 'node_modules') {    
                    await processDir(fullPath);    
                }    
                continue;    
            }    
                
            if (!entry.isFile()) continue;    
                
            const ext = path.extname(entry.name).slice(1);    
            if (!extensions.includes(ext)) continue;    
                
            const stat = fs.statSync(fullPath);    
            if (stat.size === 0 || stat.size > 4 * 1024 * 1024) continue;    
                
            try {    
                const content = fs.readFileSync(fullPath, 'utf8');    
                const result = await ceo.addRag(content, entry.name);    
                console.log(`✓ ${entry.name} (${result.totalChunks} chunks, ${result.creditsDeducted} credits)`);    
                results.succeeded++;    
                results.totalCredits += result.creditsDeducted;    
            } catch (err) {    
                console.error(`✗ ${entry.name}: ${err.message}`);    
                results.failed++;    
            }    
        }    
    }    
        
    await processDir(directory);    
    return results;    
}    
    
// Usage    
const results = await trainAgent('./docs', { recursive: true, extensions: ['md', 'txt'] });    
console.log(`\nDone: ${results.succeeded} files, ${results.totalCredits} credits`);