Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.sudoapp.dev/llms.txt

Use this file to discover all available pages before exploring further.

CRUD operations allow you to store, retrieve, update, and delete OpenAI Chat Completions for analysis, caching, and model improvement.

​
Storing Completions

​
Basic Storage

TypeScript
import { Sudo } from "sudo-ai";

const sudo = new Sudo({
  serverURL: "https://sudoapp.dev/api",
  apiKey: process.env.SUDO_API_KEY ?? "",
});

async function basicStorage() {
  try {
    // Create and store a completion
    const response = await sudo.router.create({
      model: "gpt-4o",
      messages: [
        { role: "user", content: "Explain machine learning" }
      ],
      store: true,  // Enable storage
      metadata: {
        userId: "user_123",
        topic: "education",
        session: "learning_session_1"
      }
    });
    
    const completionId = response.id;
    console.log(`Stored completion with ID: ${completionId}`);
    console.log(`Response: ${response.choices[0].message.content}`);
  } catch (error) {
    console.error("Storage error:", error);
  }
}

basicStorage();

​
Retrieving Completions

​
List Stored Completions

TypeScript
import { Sudo } from "sudo-ai";

const sudo = new Sudo({
  serverURL: "https://sudoapp.dev/api",
  apiKey: process.env.SUDO_API_KEY ?? "",
});

async function listStoredCompletions() {
  try {
    // List all stored completions
    const completions = await sudo.router.listChatCompletions({
      limit: 10,
      order: "desc"  // Most recent first
    });
    
    console.log(`Found ${completions.data.length} stored completions:`);
    completions.data.forEach(completion => {
      console.log(`- ID: ${completion.id}`);
      console.log(`  Model: ${completion.model}`);
      console.log(`  Created: ${completion.created}`);
      if (completion.metadata) {
        console.log(`  Metadata: ${JSON.stringify(completion.metadata)}`);
      }
    });
  } catch (error) {
    console.error("List completions error:", error);
  }
}

listStoredCompletions();

​
Filter by Metadata

TypeScript
import { Sudo } from "sudo-ai";

const sudo = new Sudo({
  serverURL: "https://sudoapp.dev/api",
  apiKey: process.env.SUDO_API_KEY ?? "",
});

async function filterByMetadata() {
  try {
    // Filter completions by metadata
    const completions = await sudo.router.listChatCompletions({
      metadata: {
        userId: "user_123",
        topic: "education"
      },
      limit: 5
    });
    
    console.log("Education-related completions:");
    completions.data.forEach(completion => {
      console.log(`- ${completion.id}: ${completion.model}`);
    });
  } catch (error) {
    console.error("Filter by metadata error:", error);
  }
}

filterByMetadata();

​
Get Specific Completion

TypeScript
import { Sudo } from "sudo-ai";

const sudo = new Sudo({
  serverURL: "https://sudoapp.dev/api",
  apiKey: process.env.SUDO_API_KEY ?? "",
});

async function getCompletionDetails(completionId: string) {
  try {
    // Get completion metadata
    const completion = await sudo.router.getChatCompletion(completionId);
    
    // Get completion messages
    const messages = await sudo.router.getChatCompletionMessages(completionId);
    
    return {
      completion,
      messages
    };
  } catch (error) {
    console.error("Get completion details error:", error);
    return null;
  }
}

// Usage
async function completionDetailsExample() {
  const completionId = "chatcmpl-abc123";  // Replace with actual ID
  const details = await getCompletionDetails(completionId);
  
  if (details) {
    console.log(`Completion ID: ${details.completion.id}`);
    console.log(`Model: ${details.completion.model}`);
    console.log(`Created: ${details.completion.created}`);
    console.log("\nMessages:");
    details.messages.data.forEach(message => {
      console.log(`- ${message.role}: ${message.content}`);
    });
  }
}

completionDetailsExample();

​
Updating Completions

​
Update Metadata

TypeScript
import { Sudo } from "sudo-ai";

const sudo = new Sudo({
  serverURL: "https://sudoapp.dev/api",
  apiKey: process.env.SUDO_API_KEY ?? "",
});

async function updateCompletionMetadata(completionId: string, newMetadata: Record<string, any>) {
  try {
    const updatedCompletion = await sudo.router.updateChatCompletion({
      completionId: completionId,
      metadata: newMetadata
    });
    
    return updatedCompletion;
  } catch (error) {
    console.error("Update completion metadata error:", error);
    return null;
  }
}

// Example: Add rating and feedback
async function updateMetadataExample() {
  const newMetadata = {
    userId: "user_123",
    topic: "education", 
    rating: "5",
    feedback: "very_helpful",
    reviewed: "true"
  };

  const updated = await updateCompletionMetadata("chatcmpl-abc123", newMetadata);
  if (updated) {
    console.log(`Updated completion ${updated.id}`);
    console.log(`New metadata: ${JSON.stringify(updated.metadata)}`);
  }
}

updateMetadataExample();

​
Deleting Completions

​
Delete Single Completion

TypeScript
import { Sudo } from "sudo-ai";

const sudo = new Sudo({
  serverURL: "https://sudoapp.dev/api",
  apiKey: process.env.SUDO_API_KEY ?? "",
});

async function deleteCompletion(completionId: string) {
  try {
    const result = await sudo.router.deleteChatCompletion(completionId);
    return result;
  } catch (error) {
    console.error("Delete completion error:", error);
    return null;
  }
}

// Delete a completion
async function deleteCompletionExample() {
  const result = await deleteCompletion("chatcmpl-abc123");
  if (result) {
    console.log(`Deletion result: ${JSON.stringify(result)}`);
  }
}

deleteCompletionExample();
CRUD operations are only available for completions created with store=True. This feature is designed for OpenAI API compatibility and works with both Python and TypeScript SDKs.

​
Summary

The Sudo SDK provides comprehensive functionality for building AI-powered applications in both Python and TypeScript:
  • System Endpoints: Monitor API health and discover available models
  • Chat Completion: Generate responses from various AI models with extensive customization
  • Streaming: Real-time response generation for interactive applications
  • Tool Calling: Enable AI models to execute functions and interact with external systems
  • Structured Output: Generate validated JSON responses for reliable data extraction
  • Image Input: Process images and multimodal content with vision-capable models
  • Reasoning: Access advanced reasoning capabilities for complex problem-solving
  • CRUD Operations: Manage stored completions for analysis and improvement
Both SDKs are designed for production use with comprehensive error handling, async support, and best practices built-in. Start with basic chat completions and gradually add advanced features as needed. Resources: