Custom Knowledge Base

$
curl --location 'https://api.vapi.ai/knowledge-base' \
>
--header 'Content-Type: application/json' \
>
--header 'Authorization: Bearer YOUR_VAPI_API_KEY' \
>
--data '{
>
    "provider": "custom-knowledge-base",
>
    "server": {
>
        "url": "https://your-domain.com/kb/search",
>
        "secret": "your-webhook-secret"
>
    }
>
}'

$
curl --location --request PATCH 'https://api.vapi.ai/assistant/YOUR_ASSISTANT_ID' \
>
--header 'Content-Type: application/json' \
>
--header 'Authorization: Bearer YOUR_VAPI_API_KEY' \
>
--data '{
>
    "model": {
>
        "model": "gpt-4o",
>
        "provider": "openai",
>
        "messages": [
>
            {
>
                "role": "system",
>
                "content": "Your existing system prompt and instructions..."
>
            }
>
        ],
>
        "knowledgeBaseId": "YOUR_KNOWLEDGE_BASE_ID"
>
    }
>
}'

1
import express from 'express';
2
import crypto from 'crypto';
3
4
const app = express();
5
app.use(express.json());
6
7
// Your knowledge base data (replace with actual database/vector store)
8
const documents = [
9
  {
10
    id: "return-policy-1",
11
    content: "Our return policy allows customers to return items within 30 days of purchase for a full refund. Items must be in original condition with tags attached.",
12
    category: "returns"
13
  },
14
  {
15
    id: "shipping-info-1", 
16
    content: "We offer free shipping on orders over $50. Standard shipping takes 3-5 business days.",
17
    category: "shipping"
18
  }
19
];
20
21
app.post('/kb/search', (req, res) => {
22
  try {
23
    // Verify webhook secret (recommended)
24
    const signature = req.headers['x-vapi-signature'];
25
    const secret = process.env.VAPI_WEBHOOK_SECRET;
26
    
27
    if (signature && secret) {
28
      const expectedSignature = crypto
29
        .createHmac('sha256', secret)
30
        .update(JSON.stringify(req.body))
31
        .digest('hex');
32
        
33
      if (signature !== `sha256=${expectedSignature}`) {
34
        return res.status(401).json({ error: 'Invalid signature' });
35
      }
36
    }
37
38
    const { message } = req.body;
39
    
40
    if (message.type !== 'knowledge-base-request') {
41
      return res.status(400).json({ error: 'Invalid request type' });
42
    }
43
44
    // Get the latest user message
45
    const userMessages = message.messages.filter(msg => msg.role === 'user');
46
    const latestQuery = userMessages[userMessages.length - 1]?.content || '';
47
48
    // Simple keyword-based search (replace with vector search)
49
    const relevantDocs = documents
50
      .map(doc => ({
51
        ...doc,
52
        similarity: calculateSimilarity(latestQuery, doc.content)
53
      }))
54
      .filter(doc => doc.similarity > 0.1)
55
      .sort((a, b) => b.similarity - a.similarity)
56
      .slice(0, 3);
57
58
    // Return documents for AI processing
59
    res.json({
60
      documents: relevantDocs.map(doc => ({
61
        content: doc.content,
62
        similarity: doc.similarity,
63
        uuid: doc.id
64
      }))
65
    });
66
67
  } catch (error) {
68
    console.error('Knowledge base search error:', error);
69
    res.status(500).json({ error: 'Internal server error' });
70
  }
71
});
72
73
function calculateSimilarity(query: string, content: string): number {
74
  // Simple similarity calculation (replace with proper vector similarity)
75
  const queryWords = query.toLowerCase().split(' ');
76
  const contentWords = content.toLowerCase().split(' ');
77
  const matches = queryWords.filter(word => 
78
    contentWords.some(cWord => cWord.includes(word))
79
  ).length;
80
  
81
  return matches / queryWords.length;
82
}
83
84
app.listen(3000, () => {
85
  console.log('Custom Knowledge Base server running on port 3000');
86
});

1
import { PineconeClient } from '@pinecone-database/pinecone';
2
import OpenAI from 'openai';
3
4
const pinecone = new PineconeClient();
5
const openai = new OpenAI();
6
7
app.post('/kb/search', async (req, res) => {
8
  try {
9
    const { message } = req.body;
10
    const latestQuery = getLatestUserMessage(message);
11
12
    // Generate embedding for the query
13
    const embedding = await openai.embeddings.create({
14
      model: 'text-embedding-ada-002',
15
      input: latestQuery
16
    });
17
18
    // Search vector database
19
    const index = pinecone.Index('knowledge-base');
20
    const searchResults = await index.query({
21
      vector: embedding.data[0].embedding,
22
      topK: 5,
23
      includeMetadata: true
24
    });
25
26
    // Format response
27
    const documents = searchResults.matches.map(match => ({
28
      content: match.metadata.content,
29
      similarity: match.score,
30
      uuid: match.id
31
    }));
32
33
    res.json({ documents });
34
  } catch (error) {
35
    console.error('Vector search error:', error);
36
    res.status(500).json({ error: 'Search failed' });
37
  }
38
});