Integre o MongoDB com IA do Fireworks

Você pode integrar o MongoDB ao Fireworks AI, uma plataforma de inferência e treinamento para modelos de código aberto. Este guia mostra como usar os modelos de chat do Fireworks junto com o MongoDB, o que permite fornecer contexto para as respostas do agente e configurar o armazenamento de dados do agente.

A integração do MongoDB para o Fireworks AI fornece as seguintes funcionalidades:

Dados do modelo de chat: passe os dados do MongoDB para um modelo de chat como contexto ou exponha-os a uma ferramenta que o modelo chama.
Memória do agente: persista o histórico de conversas do agente e o estado da sessão como documentos.
fonte de dados de treinamento: use os dados do MongoDB para ajustar um modelo do Fireworks e personalizar seu comportamento para seus casos de uso.

Você pode chamar modelos de chat do Fireworks usando o SDK do Fireworks ou APIs compatíveis, como a API OpenAI. As estruturas que oferecem suporte a provedores compatíveis com OpenAI, incluindo LangChain, LangGraph e LlamaIndex, também funcionam com Fireworks.

Começar

Para concluir um tutorial que usa modelos do Fireworks com o MongoDB Vector Search para criar um aplicação RAG, consulte Introdução à integração da IA do MongoDB Fireworks.

Instalação

Para instalar os pacotes necessários, execute o seguinte comando:

pip install --quiet --upgrade pymongo openai

Este comando instala os seguintes pacotes:

pymongo: O driver MongoDB Python
openai: Um cliente OpenAI , que os exemplos nesta página usam para chamar modelos de chat do Fireworks

Pacotes LangChain

Se você construir com LangChain, use a classe langchain-fireworks do pacote ChatFireworks para chamar modelos de chat do Fireworks. Execute o seguinte comando para instalar este pacote:

pip install --quiet --upgrade langchain-fireworks

Uso

Para usar modelos de chat do Fireworks com MongoDB, crie os seguintes clientes:

Um cliente, como um cliente OpenAI, configurado para usar o endpoint do Fireworks
Um cliente MongoDB para sua implementação

O exemplo a seguir cria esses dois clientes e seleciona um modelo de chat do 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 usar esse exemplo, defina as seguintes variáveis de ambiente:

FIREWORKS_API_KEY: Sua chave de API do Fireworks. Para criar uma chave de API, consulte as configurações de chaves de API.
MONGODB_URI: Sua string de conexão do MongoDB . Para saber mais sobre como localizar sua string de conexão, consulte Conectar-se a um cluster por meio de bibliotecas de clientes.

Parâmetro	necessidade	Descrição
`base_url`	Obrigatório	O endpoint de inferência do Fireworks. Defina isso como `https://api.fireworks.ai/inference/v1` para que o cliente envie chamadas de API para o Fireworks em vez de para seu provedor padrão.
`api_key`	Obrigatório	Sua chave de API do Fireworks. Para criar uma, acesse API Keys nas configurações do Fireworks.

Interaja com um modelo de chat

Para enviar uma conversa para um modelo do Fireworks e receber uma resposta, chame o método chat.completions.create() no cliente do Fireworks. Esta seção mostra como personalizar as interações do modelo de chat das seguintes maneiras:

Instrua o modelo a gerar respostas a partir de dados MongoDB
Especifique uma lista de ferramentas que o modelo pode chamar
Persistir o histórico de conversa em uma collection do MongoDB

Parâmetro	necessidade	Descrição
`model`	Obrigatório	O ID do modelo de chat do Fireworks a ser usado, como `accounts/fireworks/models/gpt-oss-120b`.
`messages`	Obrigatório	A lista de dicionários de mensagens que compõem a conversa, cada um contendo uma chave `role` e `content`. Para saber mais, consulte a seguinte seção Usar dados do MongoDB como contexto.
`tools`	Opcional	Uma lista de definições de função que o modelo pode chamar. Somente modelos que suportam chamada de função, como `accounts/fireworks/models/gpt-oss-120b` e `accounts/fireworks/models/kimi-k3`, aceitam esse parâmetro. Para saber mais, consulte a seção Especificar ferramentas do agente.
`temperature`	Opcional	Um valor entre `0` e `2` que controla a aleatoriedade da resposta. Valores mais baixos produzem mais saída determinística.

Usar dados do MongoDB como contexto

Para gerar uma resposta com base no contexto fornecido por você, defina o parâmetro messages como uma lista contendo as seguintes mensagens:

system mensagem que instrui o modelo a responder apenas a partir do contexto fornecido
user mensagem que contém o contexto e a pergunta

Você pode passar qualquer resultado de query do MongoDB como contexto em sua mensagem user para gerar uma resposta a partir dos dados do MongoDB .

O exemplo a seguir faz uma query de uma collection do MongoDB para um pequeno conjunto de documentos candidatos. Em seguida, o código fornece seus títulos e gráficos como contexto para gerar uma recomendações de filme:

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 ferramentas do agente

Para especificar uma lista de ferramentas que os modelos de chat do Fireworks compatíveis podem chamar, use o parâmetro tools. Defina este parâmetro como uma lista de definições de função, cada uma contendo o nome, a descrição e os parâmetros de uma função.

Quando o modelo decide chamar uma função, ele retorna uma lista tool_calls na mensagem de resposta em vez de uma resposta de texto. Seu código executa a função nomeada e envia o resultado de volta como uma mensagem de tool para continuar a conversa. Use esse padrão para criar um agente que decide quando chamar uma ferramenta, como uma função que consulta sua coleção do MongoDB .

Este exemplo executa as seguintes ações:

Define uma ferramenta search_movies que consulta o MongoDB
Permite que o modelo decida se chama a ferramenta
Executa a ferramenta search_movies e envia o resultado de volta para o modelo, se o modelo solicitar
Gera uma recomendações 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.

Memória persistente do agente

Para configurar um agente que se lembra das voltas de conversa anteriores, armazene cada mensagem em uma coleção MongoDB . Em seguida, carregue o histórico de mensagens na lista messages sempre que chamar o método chat.completions.create(). Armazene um valor session_id em cada documento de mensagem para atribuir o histórico armazenado a uma única conversa.

Este exemplo executa as seguintes ações:

Carrega qualquer histórico de mensagens existente para a sessão da collection chat_history
Anexa uma nova mensagem de usuário e chama chat.completions.create() com o histórico combinado
Salva a nova mensagem do usuário e a resposta do modelo na coleção 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...

Como o agente carrega mensagens anteriores da coleção chat_history em cada chamada, uma chamada futura que use o mesmo valor de session_id pode referir-se a esta conversa.

Modelos de treinamento em dados MongoDB

Você pode treinar um modelo de chat de código aberto existente nos dados armazenados no MongoDB para personalizar seu comportamento para casos de uso específicos e melhorar sua precisão.

Para usar dados do MongoDB para o treinamento do modelo, seus documentos devem armazenar uma array messages no formato de chat esperado pelo Fireworks. Exporte esses documentos da sua coleção para um arquivo JSONL, onde cada linha é a array messages de um documento. Em seguida, faça o upload do conjunto de dados e use firectl, a CLI do Fireworks, para iniciar o ajuste fino supervisado.

Execute os seguintes comandos para carregar um conjunto de dados e treinar novamente um 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>

Quando o treinamento terminar, implemente o modelo tuned e use seu ID de modelo no lugar de um ID de modelo base em suas chamadas de chat. Para saber mais sobre os modelos básicos suportados, os métodos de treinamento e as opções de implantação, consulte Ajuste fino supervisado na documentação do Fireworks.