Sfruttare Milvus e Friendli Serverless Endpoints per RAG avanzata e query multimodali
FriendliAI è specializzata nell'infrastruttura di IA generativa, offrendo soluzioni che consentono alle organizzazioni di distribuire e gestire in modo efficiente grandi modelli linguistici (LLM) e altri modelli di IA generativa con prestazioni ottimizzate e costi ridotti. Gli utenti hanno la possibilità di scegliere tra LLM convenzionali pronti per la produzione accessibili tramite API, oppure LLM personalizzati sottoposti a fine-tuning distribuiti sull'hardware scelto dall'utente, sia sul cloud pubblico sia su cluster privati on-premise.
Milvus è un database vettoriale open-source che memorizza, indicizza e ricerca dati non strutturati su scala miliardaria tramite embedding vettoriali ad alta dimensionalità. È perfetto per creare applicazioni di IA moderne come retrieval augmented generation (RAG), ricerca semantica, ricerca multimodale e sistemi di raccomandazione.
In questo articolo, esploreremo come utilizzare Milvus con Friendli Serverless Endpoints per eseguire la Retrieval-Augmented Generation (RAG) su documenti e materiali specifici ed eseguire query multimodali che incorporano immagini e altri contenuti visivi. Questa potente combinazione consente applicazioni di IA più sofisticate e consapevoli del contesto.
Comprendere RAG e i modelli multimodali
Retrieval-Augmented Generation (RAG)
RAG è una tecnica che potenzia i modelli linguistici fornendo loro informazioni pertinenti, recuperate principalmente da una base di conoscenza basata su database vettoriale. Questo approccio consente ai modelli di IA di generare risposte più accurate e contestualmente appropriate facendo riferimento a fonti di dati esterne designate.
Modelli multimodali
I modelli multimodali possono elaborare e comprendere più tipi di dati di input, come testo, immagini e audio. Possono analizzare e generare risposte basate su fonti di informazione diverse, consentendo interazioni più complete e sfumate.
Perché incorporare insieme RAG e modelli multimodali?
La combinazione di RAG e capacità multimodali migliora significativamente i sistemi di IA fornendo simultaneamente le seguenti funzionalità:
- Consentire tipi di input più diversi e ricchi a scelta dell'utente
- Fornire informazioni aggiornate
- Migliorare l'accuratezza e la pertinenza delle risposte
- Abilitare interazioni consapevoli del contesto
Implementazione pratica
Immergiamoci nell'implementazione pratica di RAG e query multimodali utilizzando il database vettoriale Milvus e Friendli Serverless Endpoints.
Passaggio 1: installare i prerequisiti e scaricare la documentazione di Milvus
Per prima cosa, installeremo le librerie necessarie e scaricheremo la documentazione di Milvus che utilizzeremo per il nostro job RAG:
!pip install --upgrade pymilvus requests tqdm langchain langchain-community langchain-huggingface langchain-openai friendli-client tiktoken
!wget https://github.com/milvus-io/milvus-docs/releases/download/v2.4.6-preview/milvus_docs_2.4.x_en.zip
!rm -rf milvus_docs
!unzip -q milvus_docs_2.4.x_en.zip -d milvus_docs
Passaggio 2: elaborare i file della documentazione
Successivamente, leggeremo i file della documentazione di Milvus e useremo una semplice strategia di suddivisione dei file per trattare ogni riga di testo come un singolo chunk:
from glob import glob
text_lines = []
for file_path in glob("milvus_docs/en/faq/*.md", recursive=True):
with open(file_path, "r") as file:
file_text = file.read()
text_lines += file_text.split("# ")
Passaggio 3: Preparare gli embedding
Useremo la libreria di embedding di Hugging Face per utilizzare un semplice modello all-MiniLM-L6 per creare rappresentazioni vettoriali del nostro testo:
from langchain_huggingface import HuggingFaceEmbeddings
embeddings_model_name = "sentence-transformers/all-MiniLM-L6-v2"
embedding = HuggingFaceEmbeddings(model_name=embeddings_model_name)
test_embedding = embedding.embed_query("This is a test")
embedding_dim = len(test_embedding)
print(embedding_dim)
print(test_embedding[:10])
Passaggio 4: Configurare il client Milvus
Ora prepariamo il client Milvus per la nostra implementazione RAG. In questo semplice esempio, usiamo Milvus Lite, che viene eseguito localmente e materializza un file in un file locale. Puoi anche considerare altre opzioni di distribuzione di Milvus:
Se hai bisogno solo di un database vettoriale locale per dati su piccola scala o prototipazione, impostare l'uri come file locale, ad es../milvus.db, è il metodo più comodo, poiché utilizza automaticamente Milvus Lite per archiviare tutti i dati in questo file.
Per dati e traffico su scala più ampia in produzione, puoi configurare un server Milvus su Docker o Kubernetes. In questa configurazione, usa l'indirizzo e la porta del server come tuo uri, ad es.http://localhost:19530. Se abiliti la funzionalità di autenticazione su Milvus, imposta il token come "<your_username>:<your_password>", altrimenti non è necessario impostare il token.
Puoi anche usare Milvus completamente gestito su Zilliz Cloud. Imposta semplicemente uri e token sull'Endpoint pubblico e chiave API della tua istanza Zilliz Cloud.
from pymilvus import MilvusClient
milvus_client = MilvusClient(uri="./milvus_demo.db")
collection_name = "my_rag_collection"
Passaggio 5: Creare una collection Milvus
Creeremo una collection nel client Milvus se non esiste già:
if milvus_client.has_collection(collection_name):
milvus_client.drop_collection(collection_name)
milvus_client.create_collection(
collection_name=collection_name,
dimension=embedding_dim,
metric_type="IP", # Inner product distance
consistency_level="Strong", # Strong consistency level
)
Passaggio 6: Incorporare e inserire il testo in Milvus
Incorporiamo il nostro testo e inseriamolo nella collection Milvus:
from tqdm import tqdm
data = []
for i, line in enumerate(tqdm(text_lines, desc="Creating embeddings")):
data.append({"id": i, "vector": embedding.embed_query(line), "text": line})
milvus_client.insert(collection_name=collection_name, data=data)
Passaggio 7: Eseguire una query RAG
Ora possiamo fare una domanda e cercare dati pertinenti all'interno del nostro database Milvus:
question = "How is data stored in milvus?"
search_res = milvus_client.search(
collection_name=collection_name,
data=[
embedding.embed_query(question)
],
limit=3, # Return top 3 results
search_params={"metric_type": "IP", "params": {}}, # Inner product distance
output_fields=["text"], # Return the text field
)
import json
retrieved_lines_with_distances = [
(res["entity"]["text"], res["distance"]) for res in search_res[0]
]
print(json.dumps(retrieved_lines_with_distances, indent=4))
context = "\n".join(
[line_with_distance[0] for line_with_distance in retrieved_lines_with_distances]
)
Passaggio 8: Creare prompt per RAG
Creiamo i prompt di sistema e utente per la nostra query RAG:
SYSTEM_PROMPT = """
Human: You are an AI assistant. You are able to find answers to the questions from the contextual passage snippets provided.
"""
USER_PROMPT = f"""
Use the following pieces of information enclosed in <context> tags to provide an answer to the question enclosed in <question> tags.
<context>
{context}
</context>
<question>
{question}
</question>
"""
Passaggio 9: Configurare il token Friendli
Ottieni il tuo FRIENDLI_TOKEN dalla Friendli Suite e impostalo come variabile d’ambiente:
import os
if "FRIENDLI_TOKEN" not in os.environ:
os.environ["FRIENDLI_TOKEN"] = 'flp_FILL_IN_WITH_YOUR_OWN_PERSONAL_ACCESS_TOKEN'
Passaggio 10: Eseguire la query RAG
Ora possiamo eseguire la nostra query RAG usando i Friendli Serverless Endpoints:
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="meta-llama-3.1-70b-instruct",
base_url="https://api.friendli.ai/serverless/v1",
api_key=os.environ["FRIENDLI_TOKEN"],
)
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
prompt = ChatPromptTemplate.from_messages([
("system", SYSTEM_PROMPT),
("user", USER_PROMPT)
])
output_parser = StrOutputParser()
chain = prompt | llm | output_parser
print(chain.invoke({"input": question}))
Questo produce la risposta basata sui documenti forniti:
In Milvus, data is stored in two forms: inserted data and metadata.
Inserted data (vector data, scalar data, and collection-specific schema) is stored in persistent storage as incremental logs. Milvus supports multiple object storage backends, including MinIO, AWS S3, Google Cloud Storage (GCS), Azure Blob Storage, Alibaba Cloud OSS, and Tencent Cloud Object Storage (COS).
Metadata, on the other hand, is generated within Milvus and is stored in etcd, with each Milvus module having its own metadata.
Passaggio 11: Query multimodali
Per le query multimodali, useremo il modello Llama-3.2-11b-vision:
multimodalllm = ChatOpenAI(
model="llama-3.2-11b-vision-instruct",
base_url="https://api.friendli.ai/serverless/beta",
api_key=os.environ["FRIENDLI_TOKEN"],
)
image_url = "https://milvus.io/docs/v2.4.x/assets/highly-decoupled-architecture.png"
message = HumanMessage(
content=[
{"type": "text", "text": "describe what is in this image"},
{"type": "image_url", "image_url": {"url": image_url}},
],
)
response = multimodalllm.invoke([message])
print(response.content)
Dalla sua risposta, possiamo dedurre che il modello comprende correttamente l’immagine:
The image depicts a flowchart of the components of a system, with the following components:
**Coordinator Service**
* Root
* Query
…
Passaggio 12: Combinare le funzionalità RAG e multimodali
Infine, combiniamo le funzionalità RAG e multimodali:
question = "How is data stored in milvus with respect to this picture?"
USER_PROMPT = f"""
Use the following pieces of information enclosed in <context> tags to provide an answer to the question enclosed in <question> tags.
<context>
{context}
</context>
<question>
{question}
</question>
"""
message = HumanMessage(
content=[
{"type": "text", "text": USER_PROMPT},
{"type": "image_url", "image_url": {"url": image_url}},
],
)
response = multimodalllm.invoke([message])
print(response.content)
Il modello genera correttamente una risposta corretta basata sull’immagine e sui documenti:
**Step 1: Identify the components involved in storing data in Milvus.**
The components involved in storing data in Milvus include:
* Access Layer
* Message Storage
* Worker Node
**Step 2: Determine how data is stored in Milvus.**
Data is stored in the Access Layer and Message Storage.
**Passaggio 3: Determinare dove vengono archiviati i dati in Milvus.**
I dati vengono archiviati sia nell'Access Layer sia nel Message Storage.
**Risposta:** I dati vengono archiviati sia nell'Access Layer sia nel Message Storage.
Per il codice completo e maggiori dettagli, consulta questo notebook Colab.
Conclusione
Questo tutorial ha dimostrato come sfruttare Milvus e Friendli Serverless Endpoints per implementare RAG avanzata e query multimodali. Combinando queste potenti tecnologie, puoi creare applicazioni di IA più sofisticate, in grado di comprendere ed elaborare diversi tipi di informazioni, portando a risposte più accurate e consapevoli del contesto.
Continua a leggere
The AWS Outage Was a Wake-Up Call for Vector Database Cross-Region Disaster Recovery
Zilliz Cloud Had the Answer Before the Crisis. Zilliz Cloud is the world's first vector database with native cross-region disaster recovery.
Why Not All VectorDBs Are Agent-Ready
Explore why choosing the right vector database is critical for scaling AI agents, and why traditional solutions fall short in production.
Bringing AI to Legal Tech: The Role of Vector Databases in Enhancing LLM Guardrails
Discover how vector databases enhance AI reliability in legal tech, ensuring accurate, compliant, and trustworthy AI-powered legal solutions.