Introduzione al RAG

Dettagli su ciascuna fase

1. Retrieval delle informazioni

Questa fase consiste nel cercare dati pertinenti in grandi collezioni di documenti o basi di dati. Il recupero viene spesso effettuato tramite modelli di similarità semantica, embedding vettoriali, o motori di ricerca specializzati.

Lo sviluppatore lavora per configurare queste fonti e integrare tecnologie di ricerca per garantire che il sistema trovi le informazioni più utili possibile.

2. Ranking

Dopo il recupero, sono probabilmente disponibili molteplici risultati. La funzione del ranking è ordinare questi risultati in modo che quelli più rilevanti e affidabili siano presentati per primi.

Lo sviluppatore definisce i criteri e crea o affina modelli che valutano la pertinenza basandosi su fattori come:

Similitudine tra domanda e testo;
Affidabilità e autorevolezza della fonte;
Aggiornamento temporale del documento;
Feedback degli utenti.

Questo assicura che la risposta generata sarà basata sulle fonti migliori e più pertinenti, migliorando l’esperienza per l’utente finale.

3. Costruzione dei prompt

Questa è la fase in cui i dati recuperati e ordinati vengono trasformati in un input chiaro e utile per il modello AI generativo.

Anche se l’utente finale fornisce una domanda generica, lo sviluppatore crea template di prompt che includono istruzioni e modalità di interpretazione per far sì che l’AI dia risposte più precise e contestualizzate.

Esempio di prompt:

“Qui ci sono alcune informazioni da utilizzare per rispondere alla domanda: Qual è la capitale della Francia?
[Inserisci le informazioni recuperate]
Rispondi in modo sintetico e chiaro.”

La costruzione accurata e l’ingegneria di questi prompt è cruciale per le performance del sistema RAG.

Come implementare un sistema RAG in un chatbot con OpenAI

Per creare un sistema RAG che integri modelli OpenAI, una pratica comune è utilizzare l’endpoint di /embeddings per indicizzare e cercare i dati testuali, associandoli alla generazione basata sul modello di linguaggio.

Schema semplificato di funzionamento:

1. Indicizzazione dati
Convertire documenti o testi in vettori embedding da salvare e indicizzare.

2. Ricerca embedding
Per ogni domanda utente, calcolare embedding domanda e recuperare testi simili.

3. Costruzione prompt
Creare un prompt che include i testi recuperati da usare come contesto.

4. Generazione risposta
Inviare il prompt al modello OpenAI chat completions per ottenere la risposta.

Esempio di pseudo-codice generale

// 1. Creare embeddings per i documenti e salvarli nel database
for each document in corpus:
embedding = openai.createEmbedding(document.text)
save embedding in db

// 2. All’arrivo di una domanda utente
question_embedding = openai.createEmbedding(user_question)
similar_docs = fetchFromDBBySimilarity(question_embedding)

// 3. Costruire il prompt con i testi simili
prompt = "Rispondi in base a questo contesto:\n" + concat(similar_docs.texts) + "\nDomanda: " + user_question

// 4. Usare chat completions per generare risposta
response = openai.chatCompletion(prompt)

Esempio semplificato in JavaScript con fetch (Node.js o browser)

async function getEmbedding(text) {
const response = await fetch('https://api.openai.com/v1/embeddings', {
method: 'POST',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json',
},
body: JSON.stringify({
input: text,
model: 'text-embedding-3-large'
}),
});
const data = await response.json();
return data.data[0].embedding;
}

async function searchSimilarDocs(queryEmbedding) {
// Qui potresti fare una ricerca in un db vettoriale (es. Pinecone, Weaviate)
// Per esempio: cerca i documenti con embedding più vicini
// Questo è solo un placeholder
return [
"Testo documento rilevante 1...",
"Testo documento rilevante 2..."
];
}

async function generateResponse(userQuestion) {
const questionEmbedding = await getEmbedding(userQuestion);
const similarDocs = await searchSimilarDocs(questionEmbedding);

const prompt = `Rispondi in base a questo contesto:\n${similarDocs.join('\n')}\nDomanda: ${userQuestion}`;

const chatResponse = await fetch('https://api.openai.com/v1/chat/completions', {
method: 'POST',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json',
},
body: JSON.stringify({
model: 'gpt-5-chat-latest',
messages: [{ role: "user", content: prompt }],
max_tokens: 500,
temperature: 0.7
}),
});
const chatData = await chatResponse.json();
return chatData.choices[0].message.content;
}

Esempio semplificato in PHP usando curl

<?php
function getEmbedding($text, $apiKey) {
$payload = json_encode([
'input' => $text,
'model' => 'text-embedding-3-large'
]);
$ch = curl_init('https://api.openai.com/v1/embeddings');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Content-Type: application/json',
"Authorization: Bearer $apiKey"
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
$result = curl_exec($ch);
curl_close($ch);
$json = json_decode($result, true);
return $json['data'][0]['embedding'];
}

function generateResponse($userQuestion, $similarDocsText, $apiKey) {
$prompt = "Rispondi in base a questo contesto:\n" . implode("\n", $similarDocsText) . "\nDomanda: " . $userQuestion;
$payload = json_encode([
'model' => 'gpt-5-chat-latest',
'messages' => [
['role' => 'user', 'content' => $prompt]
],
'max_tokens' => 500,
'temperature' => 0.7
]);
$ch = curl_init('https://api.openai.com/v1/chat/completions');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Content-Type: application/json',
"Authorization: Bearer $apiKey"
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
$result = curl_exec($ch);
curl_close($ch);
$json = json_decode($result, true);
return $json['choices'][0]['message']['content'] ?? '';
}
?>

Questo esempio non copre la parte di archiviazione e ricerca degli embedding (solitamente affidata a un database vettoriale come Pinecone o Weaviate), ma illustra come interagire con l'API OpenAI per la creazione di embedding e generazione di risposte.