¡Serie práctica! Cree aplicaciones RAG con Zilliz Cloud y AWS Bedrock

El equipo de la comunidad de código abierto de China realizó su primera transmisión en vivo, contando la historia detrás de la comunidad de código abierto de China en nombre de compartir".

Retrieval Augmented Generation (RAG) es un marco de inteligencia artificial que mejora la generación de texto al combinar capacidades de recuperación de información y procesamiento del lenguaje natural (NLP). Específicamente, el modelo de lenguaje en el sistema RAG consulta y busca en una base de conocimientos o base de datos externa a través de un mecanismo de recuperación que incorpora la información más reciente en la respuesta generada, lo que hace que el resultado final sea más preciso y contenga más contexto.

Zilliz Cloud ( https://zilliz.com.cn/cloud) se basa en la base de datos vectorial Milvus ( https://milvus.io/) y proporciona soluciones para almacenar y procesar datos vectorizados a gran escala, que se pueden utilizar para gestión y análisis eficientes y recuperación de datos. Los desarrolladores pueden utilizar la función de base de datos de vectores de Zilliz Cloud para almacenar y buscar vectores de incrustación masivos, mejorando aún más las capacidades del módulo de recuperación en aplicaciones RAG.

El servicio en la nube AWS Bedrock ( https://aws.amazon.com/cn/bedrock/) proporciona una variedad de modelos básicos previamente capacitados que se pueden utilizar para implementar y expandir soluciones de PNL. Los desarrolladores pueden integrar modelos de generación, comprensión y traducción de lenguajes en aplicaciones de inteligencia artificial a través de AWS Bedrock. Además, AWS Bedrock puede generar respuestas de texto relevantes y ricas en contexto, lo que aumenta aún más las capacidades de las aplicaciones RAG.

01. Utilice Zilliz Cloud y AWS Bedrock para crear aplicaciones RAG

Demostraremos cómo utilizar Zilliz Cloud con AWS Bedrock para crear aplicaciones RAG. El proceso básico se muestra en la Figura 1:

Figura 1. Proceso básico de creación de una aplicación RAG utilizando Zilliz Cloud y AWS Bedrock

#download the packages then import them
! pip install --upgrade --quiet  langchain langchain-core langchain-text-splitters langchain-community langchain-aws bs4 boto3

# For example
import bs4
import boto3

Conéctese a AWS Bedrock y Zilliz Cloud

A continuación, configure las variables de entorno necesarias para conectarse a los servicios de AWS y Zilliz Cloud. Debe proporcionar la región de servicio de AWS, la clave de acceso y el URI del punto final de Zilliz Cloud y la clave API para conectarse a los servicios de AWS Bedrock y Zilliz Cloud.

# Set the AWS region and access key environment variables
REGION_NAME = "us-east-1"
AWS_ACCESS_KEY_ID = os.getenv("AWS_ACCESS_KEY_ID")
AWS_SECRET_ACCESS_KEY = os.getenv("AWS_SECRET_ACCESS_KEY")

# Set ZILLIZ cloud environment variables
ZILLIZ_CLOUD_URI = os.getenv("ZILLIZ_CLOUD_URI")
ZILLIZ_CLOUD_API_KEY = os.getenv("ZILLIZ_CLOUD_API_KEY")

Con las credenciales de acceso proporcionadas anteriormente, creamos un cliente boto3 ( https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) para conectarnos al servicio AWS Bedrock Runtime e integrar el modelo de lenguaje AWS Bedrock en . A continuación, inicializamos una instancia de ChatBedrock ( https://python.langchain.com/v0.1/docs/integrations/chat/bedrock/), nos conectamos al cliente y especificamos el modelo de lenguaje a usar. El modelo que utilizamos en este tutorial anthropic.claude-3-sonnet-20240229-v1:0 . Este paso nos ayuda a configurar la infraestructura para generar respuestas de texto y también configura los parámetros de temperatura del modelo para controlar la diversidad de respuestas generadas. Las instancias de BedrockEmbeddings se pueden utilizar para convertir datos no estructurados, como texto ( https://zilliz.com.cn/glossary/%E9%9D%9E%E7%BB%93%E6%9E%84%E5%8C%96% E6 %95%B0%E6%8D%AE) en un vector.

# Create a boto3 client with the specified credentials
client = boto3.client(
    "bedrock-runtime",
    region_name=REGION_NAME,
    aws_access_key_id=AWS_ACCESS_KEY_ID,
    aws_secret_access_key=AWS_SECRET_ACCESS_KEY,
)

# Initialize the ChatBedrock instance for language model operations
llm = ChatBedrock(
    client=client,
    model_id="anthropic.claude-3-sonnet-20240229-v1:0",
    region_name=REGION_NAME,
    model_kwargs={"temperature": 0.1},
)

# Initialize the BedrockEmbeddings instance for handling text embeddings
embeddings = BedrockEmbeddings(client=client, region_name=REGION_NAME)

Recopilar y procesar información.

Una vez que el modelo de incrustación se inicializa correctamente, el siguiente paso es cargar datos desde una fuente externa. Cree una instancia de WebBaseLoader ( https://python.langchain.com/v0.1/docs/integrations/document_loaders/web_base/) para rastrear contenido desde la fuente web especificada.

En este tutorial, cargaremos contenido de artículos relacionados con agentes de IA. El cargador utiliza SoupStrainer de BeautifulSoup (https://www.crummy.com/software/BeautifulSoup/bs4/doc/) para analizar partes específicas de la página web, concretamente con "post-content", "post-title" y " post" -header" para garantizar que solo se recupere el contenido relevante. Luego, el cargador recupera el documento de la fuente de red especificada y proporciona una lista de contenido relacionado para su posterior procesamiento. A continuación, utilizamos la instancia de RecursiveCharacterTextSplitter ( https://python.langchain.com/v0.1/docs/modules/data_connection/document_transformers/recursive_text_splitter/) para dividir el documento recuperado en fragmentos de texto más pequeños. Esto puede hacer que el contenido sea más manejable y también puede pasar estos bloques de texto a otros componentes, como la incrustación de texto o los módulos de generación de idioma.

# Create a WebBaseLoader instance to load documents from web sources
loader = WebBaseLoader(
    web_paths=("https://lilianweng.github.io/posts/2023-06-23-agent/",),
    bs_kwargs=dict(
        parse_only=bs4.SoupStrainer(
            class_=("post-content", "post-title", "post-header")
        )
    ),
)
# Load documents from web sources using the loader
documents = loader.load()
# Initialize a RecursiveCharacterTextSplitter for splitting text into chunks
text_splitter = RecursiveCharacterTextSplitter(chunk_size=2000, chunk_overlap=200)


# Split the documents into chunks using the text_splitter
docs = text_splitter.split_documents(documents)

Generar respuesta

La plantilla de indicaciones predefine la estructura de cada respuesta, lo que puede guiar a la IA a utilizar estadísticas y números cuando sea posible y evitar inventar respuestas cuando falta el conocimiento relevante.

# Define the prompt template for generating AI responses
PROMPT_TEMPLATE = """
Human: You are a financial advisor AI system, and provides answers to questions by using fact based and statistical information when possible.
Use the following pieces of information to provide a concise answer to the question enclosed in <question> tags.
If you don't know the answer, just say that you don't know, don't try to make up an answer.
<context>
{context}
</context>

<question>
{question}
</question>

The response should be specific and use statistics or numbers when possible.

Assistant:"""
# Create a PromptTemplate instance with the defined template and input variables
prompt = PromptTemplate(
    template=PROMPT_TEMPLATE, input_variables=["context", "question"]
)

Inicialice la tienda de vectores de Zilliz y conéctese a la plataforma Zilliz Cloud. El almacén de vectores se encarga de convertir los documentos en vectores para su posterior recuperación rápida y eficaz. Luego, los documentos recuperados se formatean y organizan en texto coherente, y la IA integra información relevante en las respuestas, entregando en última instancia respuestas muy precisas y relevantes.

# Initialize Zilliz vector store from the loaded documents and embeddings
vectorstore = Zilliz.from_documents(
    documents=docs,
    embedding=embeddings,
    connection_args={
        "uri": ZILLIZ_CLOUD_URI,
        "token": ZILLIZ_CLOUD_API_KEY,
        "secure": True,
    },
    auto_id=True,
    drop_old=True,
)

# Create a retriever for document retrieval and generation
retriever = vectorstore.as_retriever()

# Define a function to format the retrieved documents
def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

Finalmente, creamos un enlace RAG completo para generar respuestas de IA. Este enlace primero recupera los documentos relacionados con la consulta del usuario del almacén de vectores, los recupera y los formatea, y luego los pasa a la plantilla de solicitud ( https://python.langchain.com/v0.1/docs/modules/model_io/prompts /) para generar una estructura de respuesta. Esta entrada estructurada luego se pasa a un modelo de lenguaje para generar una respuesta coherente, que finalmente se analiza en un formato de cadena y se presenta al usuario, proporcionando una respuesta precisa y rica en contexto.

# Define the RAG (Retrieval-Augmented Generation) chain for AI response generation
rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

# rag_chain.get_graph().print_ascii()

# Invoke the RAG chain with a specific question and retrieve the response
res = rag_chain.invoke("What is self-reflection of an AI Agent?")
print(res)

El siguiente es un resultado de respuesta de ejemplo:

Self-reflection is a vital capability that allows autonomous AI agents to improve iteratively by analyzing and refining their past actions, decisions, and mistakes. Some key aspects of self-reflection for AI agents include:
1. Evaluating the efficiency and effectiveness of past reasoning trajectories and action sequences to identify potential issues like inefficient planning or hallucinations (generating consecutive identical actions without progress).
2. Synthesizing observations and memories from past experiences into higher-level inferences or summaries to guide future behavior.

02. Ventajas de utilizar Zilliz Cloud y AWS Bedrock

Como se muestra en la Tabla 1, Zilliz Cloud se puede integrar perfectamente con AWS Bedrock para mejorar la eficiencia, escalabilidad y precisión de las aplicaciones RAG. Los desarrolladores pueden utilizar estos dos servicios para desarrollar soluciones integrales que procesen conjuntos de datos masivos, simplifiquen los procesos de aplicaciones de RAG y mejoren la precisión de las respuestas generadas por RAG.

Tabla 1. Beneficios de utilizar Zilliz Cloud y AWS Bedrock

03. Resumen

Este artículo presenta principalmente cómo utilizar Zilliz Cloud y AWS Bedrock para crear aplicaciones RAG.

Zilliz Cloud, una base de datos vectorial construida sobre Milvus, proporciona soluciones escalables de almacenamiento y recuperación para incrustar vectores, mientras que AWS Bedrock proporciona un potente modelo previamente entrenado para la generación de lenguaje. A través de un código de muestra, mostramos cómo conectarse a Zilliz Cloud y AWS Bedrock, cargar datos de fuentes externas, procesar y dividir los datos y, finalmente, crear un enlace RAG completo. La aplicación RAG creada en este artículo puede minimizar la probabilidad de que LLM produzca alucinaciones y proporcione respuestas inexactas, aprovechando al máximo la sinergia entre los modelos modernos de PNL y las bases de datos vectoriales. Esperamos que este tutorial inspire a otros a utilizar técnicas similares en la creación de aplicaciones RAG.