Document Intelligence Agent

npm install casedev ai zod

import Casedev from 'casedev';

const client = new Casedev({ apiKey: process.env.CASEDEV_API_KEY });

// Create a vault to store your knowledge base
const vault = await client.vault.create({
  name: 'Knowledge Base',
  description: 'Document intelligence agent knowledge store'
});

console.log(`Vault created: ${vault.id}`);
// Save this ID - you'll need it for queries

import Casedev from 'casedev';

const client = new Casedev({ apiKey: process.env.CASEDEV_API_KEY });
const VAULT_ID = process.env.VAULT_ID;

/**
 * Add a document or text to the knowledge base
 */
async function addToKnowledgeBase(content: string, metadata?: Record<string, string>) {
  // For text content, create a text file
  const blob = new Blob([content], { type: 'text/plain' });
  const filename = `knowledge-${Date.now()}.txt`;
  
  // Get upload URL
  const upload = await client.vault.upload(VAULT_ID, {
    filename,
    contentType: 'text/plain',
    metadata: {
      source: 'user-input',
      timestamp: new Date().toISOString(),
      ...metadata
    }
  });
  
  // Upload content
  await fetch(upload.uploadUrl, {
    method: 'PUT',
    headers: { 'Content-Type': 'text/plain' },
    body: content
  });
  
  // Trigger ingestion (generates embeddings automatically)
  await client.vault.ingest(VAULT_ID, upload.objectId);
  
  return { objectId: upload.objectId, filename };
}

/**
 * Add a file (PDF, Word, image) to the knowledge base
 */
async function addFileToKnowledgeBase(
  file: Buffer, 
  filename: string, 
  contentType: string
) {
  const upload = await client.vault.upload(VAULT_ID, {
    filename,
    contentType,
    metadata: {
      source: 'file-upload',
      timestamp: new Date().toISOString()
    }
  });
  
  await fetch(upload.uploadUrl, {
    method: 'PUT',
    headers: { 'Content-Type': contentType },
    body: file
  });
  
  // Ingestion handles OCR (if needed) and embedding generation
  const job = await client.vault.ingest(VAULT_ID, upload.objectId);
  
  return { objectId: upload.objectId, jobId: job.id };
}

/**
 * Find relevant content from the knowledge base
 */
async function findRelevantContent(query: string, topK: number = 5) {
  const results = await client.vault.search(VAULT_ID, {
    query,
    method: 'hybrid',  // Combines semantic + keyword search
    topK
  });
  
  // Format results for LLM context
  return results.chunks.map(chunk => ({
    content: chunk.text,
    source: chunk.filename,
    page: chunk.page,
    score: chunk.hybridScore
  }));
}

/**
 * Answer a question using the knowledge base
 */
async function answerQuestion(question: string) {
  // 1. Retrieve relevant context
  const relevantContent = await findRelevantContent(question);
  
  if (relevantContent.length === 0) {
    return {
      answer: "I don't have any information about that in my knowledge base.",
      sources: []
    };
  }
  
  // 2. Format context for the LLM
  const context = relevantContent
    .map((c, i) => `[${i + 1}] ${c.content} (Source: ${c.source}, Page ${c.page})`)
    .join('\n\n');
  
  // 3. Generate response with LLM
  const response = await client.llm.v1.chat.createCompletion({
    model: 'anthropic/claude-sonnet-4.5',
    messages: [
      {
        role: 'system',
        content: `You are a helpful assistant that answers questions based on the provided context.
        
Rules:
- Only use information from the provided context
- Cite sources using [1], [2], etc.
- If the context doesn't contain relevant information, say so
- Be concise and accurate`
      },
      {
        role: 'user',
        content: `Context:\n${context}\n\nQuestion: ${question}`
      }
    ],
    temperature: 0.3,
    max_tokens: 1000
  });
  
  return {
    answer: response.choices[0].message.content,
    sources: relevantContent.map(c => ({
      filename: c.source,
      page: c.page,
      excerpt: c.content.substring(0, 200) + '...'
    }))
  };
}

import { z } from 'zod';

// Define tools for the agent
const tools = {
  searchKnowledgeBase: {
    description: 'Search the knowledge base for information relevant to a question',
    parameters: z.object({
      query: z.string().describe('The search query')
    }),
    execute: async ({ query }) => {
      const results = await findRelevantContent(query);
      return results.length > 0 
        ? results 
        : 'No relevant information found in knowledge base.';
    }
  },
  
  addToKnowledgeBase: {
    description: 'Add new information to the knowledge base. Use this when the user provides facts or documents.',
    parameters: z.object({
      content: z.string().describe('The content to add'),
      topic: z.string().optional().describe('Topic or category')
    }),
    execute: async ({ content, topic }) => {
      const result = await addToKnowledgeBase(content, { topic });
      return `Added to knowledge base: ${result.filename}`;
    }
  }
};

/**
 * Run the agent with tool support
 */
async function runAgent(userMessage: string, conversationHistory: any[] = []) {
  const messages = [
    {
      role: 'system',
      content: `You are a helpful document intelligence assistant.

Your capabilities:
1. Search your knowledge base to answer questions
2. Add new information when users provide it

Always search the knowledge base before answering factual questions.
If you don't find relevant information, say so honestly.
When adding information, confirm what was added.`
    },
    ...conversationHistory,
    { role: 'user', content: userMessage }
  ];
  
  // First call - may request tool use
  let response = await client.llm.v1.chat.createCompletion({
    model: 'anthropic/claude-sonnet-4.5',
    messages,
    tools: Object.entries(tools).map(([name, tool]) => ({
      type: 'function',
      function: {
        name,
        description: tool.description,
        parameters: tool.parameters
      }
    })),
    tool_choice: 'auto'
  });
  
  // Handle tool calls
  while (response.choices[0].message.tool_calls) {
    const toolCalls = response.choices[0].message.tool_calls;
    
    // Execute each tool
    const toolResults = await Promise.all(
      toolCalls.map(async (call) => {
        const tool = tools[call.function.name];
        const args = JSON.parse(call.function.arguments);
        const result = await tool.execute(args);
        return {
          role: 'tool',
          tool_call_id: call.id,
          content: JSON.stringify(result)
        };
      })
    );
    
    // Continue conversation with tool results
    messages.push(response.choices[0].message);
    messages.push(...toolResults);
    
    response = await client.llm.v1.chat.createCompletion({
      model: 'anthropic/claude-sonnet-4.5',
      messages,
      tools: Object.entries(tools).map(([name, tool]) => ({
        type: 'function',
        function: {
          name,
          description: tool.description,
          parameters: tool.parameters
        }
      }))
    });
  }
  
  return response.choices[0].message.content;
}