Integra MongoDB con Fireworks AI

Puedes integrar MongoDB con Fireworks AI, una plataforma de inferencia y entrenamiento para modelos de código abierto. Esta guía muestra cómo usar los modelos de chat de Fireworks junto con MongoDB, lo que te permite proporcionar contexto a las respuestas de los agentes y configurar su almacén de datos.

La integración de MongoDB para Fireworks AI ofrece las siguientes características:

Datos del modelo de chat: Pase datos de MongoDB a un modelo de chat como contexto, o expóngalos a una herramienta que el modelo utilice.
Memoria del agente: Conserva el historial de conversaciones del agente y el estado de la sesión como documentos.
Fuente de datos de entrenamiento: utilice datos de MongoDB para ajustar un modelo de Fireworks y personalizar su comportamiento según sus casos de uso.

Puedes llamar a los modelos de chat de Fireworks usando el SDK de Fireworks o API compatibles, como la API de OpenAI. Los frameworks que admiten proveedores compatibles con OpenAI, como LangChain, LangGraph y LlamaIndex, también funcionan con Fireworks.

Empezar

Para completar un tutorial que utiliza modelos de Fireworks con MongoDB Vector Search para crear una aplicación RAG, consulte la sección "Primeros pasos con la integración de IA de MongoDB Fireworks".

Instalación

Para instalar los paquetes necesarios, ejecute el siguiente comando:

pip install --quiet --upgrade pymongo openai

Este comando instala los siguientes paquetes:

pymongo: El controlador de Python para MongoDB
openai: Un cliente de OpenAI, que los ejemplos de esta página utilizan para llamar a los modelos de chat de Fireworks.

Paquetes LangChain

Si compila con LangChain, utilice la clase ChatFireworks del paquete langchain-fireworks para llamar a los modelos de chat de Fireworks. Ejecute el siguiente comando para instalar este paquete:

pip install --quiet --upgrade langchain-fireworks

Uso

Para utilizar los modelos de chat de Fireworks con MongoDB, cree los siguientes clientes:

Un cliente, como un cliente de OpenAI, configurado para usar el punto final de Fireworks.
Un cliente MongoDB para su implementación

El siguiente ejemplo crea ambos clientes y selecciona un modelo de chat Fireworks:

FIREWORKS_BASE_URL = "https://api.fireworks.ai/inference/v1"fireworks = OpenAI(    base_url=FIREWORKS_BASE_URL,    api_key=os.environ["FIREWORKS_API_KEY"],)
mongo_client = MongoClient(os.environ["MONGODB_URI"])collection = mongo_client["<database-name>"]["<collection-name>"]
CHAT_MODEL = "accounts/fireworks/models/gpt-oss-120b"

Para utilizar este ejemplo, configure las siguientes variables de entorno:

FIREWORKS_API_KEYTu clave API de Fireworks. Para crear una clave API, consulta la configuración de Claves API.
MONGODB_URI: Su cadena de conexión de MongoDB. Para obtener más información sobre cómo encontrar su cadena de conexión, consulte Conectarse a un clúster mediante bibliotecas cliente.

Parameter	Necesidad	Descripción
`base_url`	Requerido	El punto final de inferencia de Fireworks. Establézcalo en `https://api.fireworks.ai/inference/v1` para que el cliente envíe llamadas a la API de Fireworks en lugar de a su proveedor predeterminado.
`api_key`	Requerido	Tu clave API de Fireworks. Para crear una, ve a API Keys en la configuración de Fireworks.

Interactúa con un modelo de chat

Para enviar una conversación a un modelo de Fireworks y recibir una respuesta, llame al método chat.completions.create() en el cliente de Fireworks. Esta sección muestra cómo personalizar las interacciones de su modelo de chat de las siguientes maneras:

Instruye al modelo para que genere respuestas a partir de datos de MongoDB.
Especifique una lista de herramientas que el modelo puede llamar.
Conservar el historial de conversaciones en una colección de MongoDB.

Parameter	Necesidad	Descripción
`model`	Requerido	El ID del modelo de chat de Fireworks que se va a utilizar, como por ejemplo `accounts/fireworks/models/gpt-oss-120b`.
`messages`	Requerido	La lista de diccionarios de mensajes que componen la conversación, cada uno con una clave `role` y una clave `content`. Para obtener más información, consulte la sección «Usar datos de MongoDB como contexto».
`tools`	Opcional	Lista de definiciones de funciones que el modelo puede invocar. Solo los modelos que admiten la invocación de funciones, como `accounts/fireworks/models/gpt-oss-120b` y `accounts/fireworks/models/kimi-k3`, aceptan este parámetro. Para obtener más información, consulte la sección Especificar herramientas del agente.
`temperature`	Opcional	Un valor entre `0` y `2` que controla la aleatoriedad de la respuesta. Los valores más bajos producen una respuesta más determinista.

Utilice los datos de MongoDB como contexto.

Para generar una respuesta basada en el contexto que proporcione, establezca el parámetro messages en una lista que contenga los siguientes mensajes:

system mensaje que instruye al modelo para que responda solo a partir del contexto proporcionado
user mensaje que contiene el contexto y la pregunta

Puedes pasar cualquier resultado de consulta de MongoDB como contexto en tu mensaje user para generar una respuesta a partir de tus datos de MongoDB.

El siguiente ejemplo consulta una colección de MongoDB para obtener un pequeño conjunto de documentos candidatos. A continuación, el código proporciona sus títulos y sinopsis como contexto para generar una recomendación de película:

question = "Recommend a movie about a heist that goes wrong."movies = collection.find(    {"plot": {"$regex": r"\bheist\b", "$options": "i"}}, {"_id": 0, "title": 1, "plot": 1}).limit(5)context = "\n".join(f'{m["title"]}: {m["plot"]}' for m in movies)
response = fireworks.chat.completions.create(    model=CHAT_MODEL,    messages=[        {            "role": "system",            "content": "Answer using only the movies in the context. "            "If the context doesn't contain the answer, say so.",        },        {            "role": "user",            "content": f"Context:\n{context}\n\nQuestion: {question}",        },    ],)
print(response.choices[0].message.content)

**The Getaway** -- It follows a newly released ex-con and hisloyal wife as they're forced to flee after their heist goesawry.

Especificar herramientas de agente

Para especificar una lista de herramientas que los modelos de chat compatibles con Fireworks pueden utilizar, use el parámetro tools. Asigne a este parámetro una lista de definiciones de funciones, cada una con su nombre, descripción y parámetros.

Cuando el modelo decide llamar a una función, devuelve una lista tool_calls en el mensaje de respuesta en lugar de una respuesta de texto. Tu código ejecuta la función con nombre y envía el resultado como un mensaje tool para continuar la conversación. Usa este patrón para crear un agente que decida cuándo llamar a una herramienta, como una función que consulta tu colección de MongoDB.

Este ejemplo realiza las siguientes acciones:

Define una herramienta search_movies que realiza consultas en MongoDB.
Permite que el modelo decida si llamar a la herramienta.
Ejecuta la herramienta search_movies y envía el resultado de vuelta al modelo, si el modelo lo solicita.
Genera una recomendación final

AGENT_MODEL = "accounts/fireworks/models/kimi-k3"
TOOLS = [    {        "type": "function",        "function": {            "name": "search_movies",            "description": "Keyword search over movie plots in the MongoDB movie catalog.",            "parameters": {                "type": "object",                "properties": {                    "keyword": {                        "type": "string",                        "description": "A single keyword to search for in movie plots.",                    }                },                "required": ["keyword"],            },        },    }]

def search_movies(keyword):    results = collection.find(        {"plot": {"$regex": rf"\b{keyword}\b", "$options": "i"}}, {"_id": 0, "title": 1, "plot": 1}    ).limit(5)    return [f'{m["title"]}: {m["plot"]}' for m in results]

messages = [    {        "role": "system",        "content": "Call search_movies before you recommend a movie.",    },    {        "role": "user",        "content": "Recommend a movie about a heist that goes wrong.",    },]
response = fireworks.chat.completions.create(    model=AGENT_MODEL,    messages=messages,    tools=TOOLS,)message = response.choices[0].messagemessages.append(message.model_dump(exclude_none=True))
for call in message.tool_calls:    args = json.loads(call.function.arguments)    results = search_movies(**args)    messages.append(        {            "role": "tool",            "tool_call_id": call.id,            "content": json.dumps(results),        }    )
response = fireworks.chat.completions.create(model=AGENT_MODEL, messages=messages)print(response.choices[0].message.content)

I'd recommend **The Asphalt Jungle** -- it's a classic film noirabout a meticulously planned heist that initially goes offwithout a hitch, but then bad luck and double-crosses causeeverything to unravel.

Memoria persistente del agente

Para configurar un agente que recuerde los turnos de conversación anteriores, almacene cada mensaje en una colección de MongoDB. Luego, cargue el historial de mensajes en la lista messages cada vez que llame al método chat.completions.create(). Almacene un valor session_id en cada documento de mensaje para asignar el historial almacenado a una sola conversación.

Este ejemplo realiza las siguientes acciones:

Carga cualquier historial de mensajes existente para la sesión desde la colección chat_history.
Agrega un nuevo mensaje de usuario y llama a chat.completions.create() con el historial combinado.
Guarda el nuevo mensaje del usuario y la respuesta del modelo en la colección chat_history.

history = mongo_client["<database-name>"]["chat_history"]

def load_history(session_id):    return [        doc["message"]        for doc in history.find({"session_id": session_id}).sort("seq", 1)    ]

def save_messages(session_id, messages, start_seq):    history.insert_many(        {"session_id": session_id, "seq": start_seq + i, "message": message}        for i, message in enumerate(messages)    )

session_id = "demo-session"past_messages = load_history(session_id)new_messages = [{"role": "user", "content": "Recommend a movie about a heist that goes wrong."}]
response = fireworks.chat.completions.create(    model=AGENT_MODEL,    messages=past_messages + new_messages,)new_messages.append(response.choices[0].message.model_dump(exclude_none=True))
save_messages(session_id, new_messages, start_seq=len(past_messages))print(response.choices[0].message.content)

Reservoir Dogs (1992) is the quintessential heist-gone-wrongmovie. Quentin Tarantino's debut shows almost none of the heistitself...

Debido a que el agente carga los mensajes anteriores de la colección chat_history en cada llamada, una llamada futura que utilice el mismo valor session_id puede hacer referencia a esta conversación.

Entrenar modelos con datos de MongoDB

Puedes entrenar un modelo de chat de código abierto existente con datos almacenados en MongoDB para personalizar su comportamiento para casos de uso específicos y mejorar su precisión.

Para usar datos de MongoDB para el entrenamiento del modelo, tus documentos deben almacenar un array messages en el formato de chat que Fireworks espera. Exporta estos documentos de tu colección a un archivo JSONL, donde cada línea corresponde al array messages de un documento. Luego, carga el conjunto de datos y usa firectl, la interfaz de línea de comandos de Fireworks, para iniciar el ajuste fino supervisado.

Ejecute los siguientes comandos para cargar un conjunto de datos y reentrenar un modelo:

firectl dataset create <dataset-name> <path-to-jsonl-file>firectl sftj create \  --base-model <base-model-id> \  --dataset <dataset-name> \  --output-model <output-model-name>

Cuando finalice el entrenamiento, implemente el modelo optimizado y utilice su ID de modelo en lugar del ID del modelo base en sus llamadas de chat. Para obtener información sobre los modelos base compatibles, los métodos de entrenamiento y las opciones de implementación, consulte la sección "Ajuste fino supervisado" en la documentación de Fireworks.