En este tutorial, aprenderás a crear un generación aumentada por recuperación (RAG) aplicación utilizando Servicios de inteligencia artificial de Couchbase para almacenar datos, generar incrustaciones utilizando modelos de incrustación e inferencia LLM. Crearemos un sistema RAG que:
- Ingiere artículos de noticias de la Conjunto de datos de BBC News.
- Genera incrustaciones vectoriales utilizando el NVIDIA NeMo Retriever modelo a través de Capella Model Services.
- Almacena e indexa estos vectores en Couchbase Capella.
- Realiza búsquedas semánticas para recuperar el contexto relevante.
- Genera respuestas utilizando el Mistral-7B LLM alojado en Capella.
Puede encontrar el código fuente del cuaderno para este CodeLab aquí.
¿Por qué los servicios de inteligencia artificial de Couchbase?
Los servicios de inteligencia artificial de Couchbase ofrecen:
- API de inferencia y embeddings de LLM: Acceda a modelos LLM populares (por ejemplo, Llama 3) y modelos de incrustación directamente a través de Capella, sin necesidad de gestionar claves API externas ni infraestructura.
- Plataforma unificada: Aprovecha la base de datos, la vectorización, la búsqueda y el modelo en un solo lugar.
- Búsqueda vectorial integrada: Realice búsquedas semánticas directamente en sus datos JSON con una latencia de milisegundos.
Configuración de los servicios de inteligencia artificial de Couchbase
Crear un clúster en Capella
- Entrar en Couchbase Capella.
- Cree un nuevo clúster o utilice uno existente. Tenga en cuenta que el clúster debe ejecutar la última versión de Couchbase Server 8.0, que incluye los servicios de datos, consultas, índices y eventos.
- Cree un cubo.
- Cree un ámbito y una colección para los datos.
Habilitar servicios de IA
- Navega hasta la sección Servicios de IA de Capella en la interfaz de usuario.
- Implementa las incrustaciones y los modelos LLM.
- Para esta demostración, debe iniciar una incrustación y un LLM en la misma región que el clúster Capella donde se almacenarán los datos.
- Para que esta demostración funcione correctamente, es necesario implementar un LLM que tenga capacidades de llamada a herramientas, como
mistralai/mistral-7b-instruct-v0.3. Para las incrustaciones, puede elegir un modelo como elnvidia/llama-3.2-nv-embedqa-1b-v2. - Anote la URL del punto final y genere claves API.
Para obtener más información sobre el lanzamiento de modelos de IA, puede leer el documentación oficial.
Requisitos previos
Antes de empezar, asegúrate de tener instalado Python 3.10 o superior.
Paso 1: Instalar dependencias
Necesitamos el SDK de Couchbase, las integraciones de LangChain y la biblioteca de conjuntos de datos.
|
1 |
%pip install --quiet datasets==4.4.1 langchain-couchbase==1.0.0 langchain-openai==1.1.0 |
Paso 2: Configuración y conexión
Comenzaremos conectándonos a nuestro clúster Couchbase. También necesitamos configurar los puntos finales para Capella Model Services.
Nota: Los servicios Capella Model son compatibles con el formato API de OpenAI, por lo que podemos utilizar el estándar. langchain-openai biblioteca apuntándola a nuestro punto final Capella.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
import getpass from couchbase.auth import PasswordAuthenticator from couchbase.cluster import Cluster from couchbase.options import ClusterOptions from datetime import timedelta # Configuration CB_CONNECTION_STRING = getpass.getpass("Couchbase Connection String: ") CB_USERNAME = input("Database Username: ") CB_PASSWORD = getpass.getpass("Database Password: ") CB_BUCKET_NAME = input("Bucket Name: ") SCOPE_NAME = "rag" COLLECTION_NAME = "data" INDEX_NAME = "vs-index" # Model Services Config CAPELLA_MODEL_SERVICES_ENDPOINT = getpass.getpass("Capella Model Services Endpoint: ") LLM_MODEL_NAME = "mistralai/mistral-7b-instruct-v0.3" LLM_API_KEY = getpass.getpass("LLM API Key: ") EMBEDDING_MODEL_NAME = "nvidia/llama-3.2-nv-embedqa-1b-v2" EMBEDDING_API_KEY = getpass.getpass("Embedding API Key: ") # Connect to Cluster auth = PasswordAuthenticator(CB_USERNAME, CB_PASSWORD) cluster = Cluster(CB_CONNECTION_STRING, ClusterOptions(auth)) cluster.wait_until_ready(timedelta(seconds=5)) print("Successfully connected to Couchbase") |
Paso 3: Configurar la estructura de la base de datos
Debemos asegurarnos de que nuestro cubo, ámbito y colección existan para almacenar los datos de noticias.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
def setup_collection(cluster, bucket_name, scope_name, collection_name): bucket = cluster.bucket(bucket_name) manager = bucket.collections() # Create Scope if scope_name not in [s.name for s in manager.get_all_scopes()]: manager.create_scope(scope_name) # Create Collection bucket_manager = bucket.collections() scopes = bucket_manager.get_all_scopes() # ... (logic to create collection if missing) ... # Create Primary Index cluster.query(f"CREATE PRIMARY INDEX IF NOT EXISTS ON `{bucket_name}`.`{scope_name}`.`{collection_name}`").execute() setup_collection(cluster, CB_BUCKET_NAME, SCOPE_NAME, COLLECTION_NAME) |
Paso 4: Carga del índice de búsqueda vectorial de Couchbase
La búsqueda semántica requiere una forma eficiente de recuperar documentos relevantes basándose en la consulta del usuario. Aquí es donde entra en juego Couchbase Vector Search, anteriormente conocido como servicio Full-Text Search (FTS). En este paso, cargamos la definición del índice de búsqueda vectorial desde un archivo JSON, que especifica cómo debe estructurarse el índice. Esto incluye los campos que se van a indexar, las dimensiones de los vectores y otros parámetros que determinan cómo el motor de búsqueda procesa las consultas basándose en la similitud vectorial.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 |
# If you are running this script in Google Colab, comment the following line # and provide the path to your index definition file. index_definition_path = "capella_index.json" # Local setup: specify your file path here # If you are running in Google Colab, use the following code to upload the index definition file # from google.colab import files # print("Upload your index definition file") # uploaded = files.upload() # index_definition_path = list(uploaded.keys())[0] try: with open(index_definition_path, "r") as file: index_definition = json.load(file) # Update search index definition with user inputs index_definition['name'] = INDEX_NAME index_definition['sourceName'] = CB_BUCKET_NAME # Update types mapping old_type_key = next(iter(index_definition['params']['mapping']['types'].keys())) type_obj = index_definition['params']['mapping']['types'].pop(old_type_key) index_definition['params']['mapping']['types'][f"{SCOPE_NAME}.{COLLECTION_NAME}"] = type_obj except Exception as e: raise ValueError( f"Error loading index definition from {index_definition_path}: {str(e)}" ) # Create the Vector Index via SDK try: scope_index_manager = ( cluster.bucket(CB_BUCKET_NAME).scope(SCOPE_NAME).search_indexes() ) # Check if index already exists existing_indexes = scope_index_manager.get_all_indexes() index_name = index_definition["name"] if index_name in [index.name for index in existing_indexes]: print(f"Index '{index_name}' found") else: print(f"Creating new index '{index_name}'...") # Create SearchIndex object from JSON definition search_index = SearchIndex.from_json(index_definition) # Upsert the index (create if not exists, update if exists) scope_index_manager.upsert_index(search_index) print(f"Index '{index_name}' successfully created/updated.") except Exception as e: logging.error(f"Error creating or updating index: {e}") |
Paso 5: Inicializar los modelos de IA
Aquí está la magia: inicializamos el modelo de incrustación utilizando OpenAIEmbeddings pero apúntalo a Capella. Los servicios de inteligencia artificial de Couchbase proporcionan puntos finales compatibles con OpenAI que utilizan los agentes. Para las incrustaciones, utilizamos el paquete LangChain OpenAI, ya que se utiliza en asociación con la integración de LangChain Couchbase.
|
1 2 3 4 5 6 7 8 9 |
from langchain_openai import OpenAIEmbeddings embeddings = OpenAIEmbeddings( openai_api_key=EMBEDDING_API_KEY, openai_api_base=CAPELLA_MODEL_SERVICES_ENDPOINT, # Capella Endpoint model=EMBEDDING_MODEL_NAME, check_embedding_ctx_length=False, tiktoken_enabled=False ) |
Paso 6: Ingestión de datos
Cargamos el conjunto de datos de BBC News y lo incorporamos a Couchbase. El CouchbaseSearchVectorStore gestiona automáticamente la generación de incrustaciones utilizando nuestro modelo definido y su almacenamiento.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
from datasets import load_dataset from langchain_core.documents import Document from langchain_couchbase.vectorstores import CouchbaseSearchVectorStore # Load Data dataset = load_dataset('RealTimeData/bbc_news_alltime', '2024-12', split="train") unique_articles = list(set(dataset["content"]))[:100] # Limit for demo # Initialize Vector Store vector_store = CouchbaseSearchVectorStore( cluster=cluster, bucket_name=CB_BUCKET_NAME, scope_name=SCOPE_NAME, collection_name=COLLECTION_NAME, embedding=embeddings, index_name=INDEX_NAME, ) # Ingest documents = [Document(page_content=article) for article in unique_articles] vector_store.add_documents(documents) print(f"Ingested {len(documents)} documents") |
Paso 7: Construir la cadena RAG
Ahora creamos el proceso RAG. Inicializamos el LLM (volviendo a apuntar a Capella) y lo conectamos a nuestro recuperador de almacenamiento vectorial.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
from langchain_openai import ChatOpenAI from langchain_core.prompts import ChatPromptTemplate from langchain_core.runnables import RunnablePassthrough from langchain_core.output_parsers import StrOutputParser # 1. Initialize LLM llm = ChatOpenAI( openai_api_base=CAPELLA_MODEL_SERVICES_ENDPOINT, openai_api_key=LLM_API_KEY, model=LLM_MODEL_NAME, temperature=0 ) # 2. Define Prompt template = """Answer the question based only on the following context: {context} Question: {question} """ prompt = ChatPromptTemplate.from_template(template) # 3. Create Chain rag_chain = ( {"context": vector_store.as_retriever(), "question": RunnablePassthrough()} | prompt | llm | StrOutputParser() ) |
Paso 8: Ejecutar consultas
Probemos nuestro RAG.
|
1 2 3 4 5 |
query = "What was Pep Guardiola's reaction to Manchester City's recent form?" response = rag_chain.invoke(query) print(f"Question: {query}") print(f"Answer: {response}") |
Ejemplo de resultado:
Contesta: Pep Guardiola ha expresado su preocupación y frustración por el rendimiento reciente del Manchester City. Ha declarado: “No soy lo suficientemente bueno. Soy el jefe... Tengo que encontrar soluciones”. Ha reconocido los problemas defensivos del equipo y su falta de confianza.
Conclusión
En este tutorial, has aprendido a:
- Vectoriza datos con Couchbase.
- Utilice los servicios de inteligencia artificial de Couchbase para incrustaciones y LLM.
- Implementa RAG con Couchbase Vector Search.
La plataforma de base de datos unificada de Couchbase crea potentes aplicaciones de inteligencia artificial capaces de generar contenido de alta calidad y sensible al contexto.
