RAG System

private function getCachedOrCreateEmbedding($userMessage)
{
    $normalized = trim(mb_strtolower($userMessage));
    $queryHash = md5($normalized);

    // Check cache (24-hour TTL)
    $cached = $this->db->fetchOne(
        'SELECT embedding FROM query_embedding_cache 
         WHERE query_hash = :hash AND created_at > DATE_SUB(NOW(), INTERVAL 24 HOUR)',
        [':hash' => $queryHash]
    );

    if ($cached && !empty($cached['embedding'])) {
        return VectorMath::unserializeVector($cached['embedding']);
    }

    // Create new embedding
    $embedding = $this->openai->createEmbedding($userMessage);
    
    // Store in cache
    $this->db->query(
        'INSERT INTO query_embedding_cache (query_hash, embedding, created_at, last_used_at, hit_count)
         VALUES (:hash, :embedding, NOW(), NOW(), 0)',
        [':hash' => $queryHash, ':embedding' => VectorMath::serializeVector($embedding)]
    );

    return $embedding;
}

public function searchSimilar(array $queryEmbedding, $topK = 5, $threshold = 0.0, $maxCandidates = 200)
{
    // Fetch candidate vectors from active documents
    $vectors = $this->db->fetchAll(
        "SELECT v.id, v.document_id, v.chunk_text, v.chunk_index, v.embedding, 
                d.filename, d.original_name 
         FROM vectors v 
         INNER JOIN documents d ON v.document_id = d.id 
         WHERE d.is_active = 1
         ORDER BY RAND()
         LIMIT {$maxCandidates}"
    );
    
    $results = [];
    
    foreach ($vectors as $vector) {
        $storedEmbedding = VectorMath::unserializeVector($vector['embedding']);
        
        // Calculate cosine similarity
        $score = VectorMath::cosineSimilarity($queryEmbedding, $storedEmbedding);

        if ($score >= $threshold) {
            $results[] = [
                'id' => $vector['id'],
                'document_id' => $vector['document_id'],
                'chunk_text' => $vector['chunk_text'],
                'score' => $score,
                'original_name' => $vector['original_name']
            ];
        }
    }

    // Sort by score and return top K
    usort($results, function($a, $b) {
        return $b['score'] <=> $a['score'];
    });

    return array_slice($results, 0, $topK);
}

$contextParts = [];
$sources = [];
$maxScore = 0;

foreach ($similarChunks as $chunk) {
    $contextParts[] = $chunk['chunk_text'];
    $sources[] = [
        'document' => $chunk['original_name'],
        'score' => $chunk['score']
    ];
    $maxScore = max($maxScore, $chunk['score']);
}

$context = implode("\n\n", $contextParts);

public function generateResponse($userMessage, $systemPrompt = null, 
                                  $conversationHistory = [], $temperature = 0.7, $maxTokens = 500)
{
    // Get query embedding (cached or new)
    $queryEmbedding = $this->getCachedOrCreateEmbedding($userMessage);
    
    // Search for similar chunks
    $similarChunks = $this->vectorSearch->searchSimilar(
        $queryEmbedding,
        $this->topK,      // Default: 3
        $this->threshold  // Default: 0.7
    );

    if (empty($similarChunks)) {
        return [
            'response' => null,
            'context' => '',
            'confidence' => 0.0,
            'sources' => []
        ];
    }

    // Assemble context from chunks
    $context = implode("\n\n", array_column($similarChunks, 'chunk_text'));
    
    // Generate response using OpenAI
    $response = $this->openai->generateResponse(
        $userMessage, 
        $context, 
        $systemPrompt, 
        $temperature, 
        $maxTokens, 
        $conversationHistory
    );

    return [
        'response' => $response,
        'context' => $context,
        'confidence' => $maxScore,
        'sources' => $sources
    ];
}