Criação de um aplicativo RAG nativo com Ollama+LangChain

🚀 Convite para experimentar: o primeiro software de programação inteligente AI IDE da China Download da versão chinesa do TraeO DeepSeek-R1 e o Doubao-pro estão disponíveis em uma base ilimitada!

O tutorial pressupõe que você já esteja familiarizado com os seguintes conceitos.

Modelos de bate-papo
Encadeamento de runnables
Embeddings
Lojas de vetores
Geração aumentada por recuperação

Muitos itens populares, como llama.cpp , Ollama e llamafile mostra a importância de executar grandes modelos de linguagem em ambientes locais.

O LangChain é semelhante a uma série de aplicativos executados localmente Fornecedores de LLM de código aberto Existem integrações, e o Ollama é uma delas.

Configurações ambientais

Primeiro, precisamos configurar o ambiente.

O repositório GitHub da Ollama fornece uma descrição detalhada, resumida a seguir.

Faça o download e execute o aplicativo Ollama
Na linha de comando, consulte a lista de modelos do Ollama e o arquivo Lista de modelos de incorporação de texto Puxando o modelo. Nesse tutorial, usamos o lhama 3.1:8b responder cantando texto nômico incorporado Exemplo.
- entrada de linha de comando ollama pull llama3.1:8bExtração de modelos genéricos de linguagens grandes de código aberto lhama 3.1:8b
- entrada de linha de comando ollama pull nomic-embed-text puxar Modelo de incorporação de texto texto nômico incorporado
Quando o aplicativo estiver em execução, todos os modelos estarão automaticamente na pasta localhost:11434 ir contra a corrente
Observe que a seleção do modelo precisa levar em conta os recursos do hardware local, o tamanho da memória de vídeo de referência para este tutorial Memória da GPU > 8 GB

Em seguida, instale os pacotes necessários para a incorporação local, o armazenamento de vetores e a inferência de modelos.

# langchain_community
%pip install -qU langchain langchain_community
# Chroma
%pip install -qU langchain_chroma
# Ollama
%pip install -qU langchain_ollama

Observação: talvez seja necessário reiniciar o kernel para usar os pacotes atualizados.
Observação: talvez seja necessário reiniciar o kernel para usar os pacotes atualizados.
Observação: talvez seja necessário reiniciar o kernel para usar os pacotes atualizados.

Você também pode Veja esta página para obter uma lista completa dos modelos de incorporação disponíveis

Carregamento de documentos

Agora vamos carregar e dividir um documento de amostra.

Usaremos o artigo de Lilian Weng sobre o Agente blog (palavra emprestada) Por exemplo.

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import WebBaseLoader
loader = WebBaseLoader("https://lilianweng.github.io/posts/2023-06-23-agent/")
dados = loader.load()
text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=0)
all_splits = text_splitter.split_documents(data)

Em seguida, o armazenamento de vetores é inicializado. O modelo de incorporação de texto que usamos é texto nômico incorporado .

from langchain_chroma import Chroma
from langchain_ollama import OllamaEmbeddings
local_embeddings = OllamaEmbeddings(model="nomic-embed-text")
vectorstore = Chroma.from_documents(documents=all_splits, embedding=local_embeddings)

Agora temos um banco de dados vetorial local! Vamos testar brevemente a pesquisa de similaridade.

question = "Quais são as abordagens para a decomposição de tarefas?"
docs = vectorstore.similarity_search(question)
len(docs)

docs[0]

Document(metadata={'description': 'Criar agentes com LLM (modelo de linguagem grande) como seu controlador principal é um conceito interessante. demonstrações de conceitos, como AutoGPTA potencialidade do LLM vai além da geração de cópias, histórias, ensaios e programas bem escritos; ele pode ser enquadrado como um poderoso solucionador de problemas gerais. Em um sistema de agente autônomo com LLM, o LLM funciona como o cérebro do agente, complementado por vários outros LLMs. O LLM funciona como o cérebro do agente, complementado por vários componentes-chave:', 'language': 'en', 'source': 'https://lilianweng.github.io/posts/2023-06 -23-agent/', 'title': "LLM Powered Autonomous Agents | Lil'Log"}, page_content='A decomposição de tarefas pode ser feita (1) pelo LLM com instruções simples como " Steps for XYZ.\\\n1.", "What are the subgoals for achieving XYZ?", (2) usando instruções específicas da tarefa; por exemplo, "Write a história para escrever um romance, ou (3) com entradas humanas").

Em seguida, instanciar o modelo de linguagem grande lhama 3.1:8b e testar se o raciocínio do modelo está funcionando corretamente:

from langchain_ollama import ChatOllama
modelo = ChatOllama(
model="llama3.1:8b", )
)

response_message = model.invoke(
"Simular uma batalha de rap entre Stephen Colbert e John Oliver"
)
print(response_message.content)

**No canto azul, temos Stephen Colbert, também conhecido como o próprio "The O'Reilly Factor". No canto vermelho, o desafiante, John Oliver. No canto azul, temos Stephen Colbert, também conhecido como o próprio "The O'Reilly Factor", e no canto vermelho, o desafiante, John Oliver.
**Stephen Colbert (também conhecido como "The Truth with a Twist"):**
Sou o rei da sátira, aquele que todos temem
Meu programa vai ao ar tarde, mas minhas piadas são claras
Eu espeto os políticos, com precisão e poder
Eles tremem diante de minha inteligência, dia e noite
**John Oliver:**
Espere, Stevie boy, você pode ter tido seu tempo
Mas eu sou o novo garoto no quarteirão, com um estilo diferente
É hora de acordar do coma dos anos 90, filho.
Meu programa tem mordida, e meus fatos nunca terminam
**Stephen Colbert:**
Oh, então você acha que é o único, com a coroa da "Última Semana".
Mas suas piadas são velhas, como as que eu usei
Sou o mestre do absurdo, o senhor do giro
Você é apenas uma importação britânica, tentando se encaixar
*John Oliver:*
Stevie, meu amigo, você pode ter sido o primeiro
Mas eu tenho a habilidade e a sagacidade, que nunca se confundem
Meu show não tem medo de entrar na briga
Eu sou aquele que fará você pensar, aconteça o que acontecer
**Stephen Colbert:**
Bem, é hora de um confronto, como dois velhos amigos
Vamos ver de quem é a sátira que reina suprema, até o fim
Mas eu tenho um segredo, que pode selar seu destino
Meu humor é contagioso, e já é tarde demais!
#John Oliver:#
Vamos lá, Stevie!
Vou aceitar suas piadas e mostrar a eles o que fazer
Meu sarcasmo é afiado, como um bisturi na noite
Você é apenas uma relíquia do passado, sem luta
**Os juízes deliberam, avaliando as rimas e o fluxo. Finalmente, eles anunciam sua decisão:**
Tina Fey: Tenho que escolher John Oliver. Suas piadas foram mais afiadas e sua apresentação foi mais suave.
Larry Wilmore: Concordo, mas Stephen Colbert ainda tem aquele charme da velha guarda.
Larry Wilmore: Concordo, mas Stephen Colbert ainda tem aquele charme da velha guarda.
Patton Oswalt: É um empate. Os dois trouxeram o calor! **A multidão vai à loucura quando os dois oponentes fazem uma reverência. A batalha do rap pode ter acabado, mas a guerra da sátira está apenas começando...

Construção de expressões em cadeia

Podemos passar o documento recuperado e um prompt simples para criar um cadeia de compactação .

Ele formata o modelo de prompt usando os valores de chave de entrada fornecidos e passa a cadeia de caracteres formatada para o modelo especificado:

from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
prompt = ChatPromptTemplate.from_template(
"Resuma os principais temas nestes documentos recuperados: {docs}"
)
# Converter os documentos recebidos em uma cadeia de caracteres
def format_docs(docs):
return "\n\n".join(doc.page_content for doc in docs)
chain = {"docs": format_docs} | prompt | model | StrOutputParser()
question = "Quais são as abordagens para a decomposição de tarefas?"
docs = vectorstore.similarity_search(question)
chain.invoke(docs)

Os principais temas desses documentos são:\n\n1. **Decomposição de tarefas**: o processo de dividir tarefas complexas em subobjetivos menores e gerenciáveis é É crucial para o manuseio eficiente de tarefas.\n2 **Sistema de agente autônomo**: um sistema alimentado por modelos de linguagem grande (LLMs) que pode executar o planejamento, o gerenciamento e a administração de tarefas. reflexãoOs LLMs também são incentivados a usar seus próprios recursos para melhorar a qualidade dos resultados finais.\n3. **Desafios no planejamento e na decomposição**:\n\t* O planejamento de longo prazo e a decomposição de tarefas \n\t* O planejamento de longo prazo e a decomposição de tarefas são desafiadores para os LLMs.\n\t* Ajustar os planos diante de erros inesperados é difícil para os LLMs.\n\t* Os seres humanos aprendem por tentativa e erro, o que os torna mais robustos do que os LLMs. Os humanos aprendem por tentativa e erro, o que os torna mais robustos do que os LLMs em determinadas situações.\n\nNo geral, os documentos destacam a importância da decomposição de tarefas e do planejamento De modo geral, os documentos destacam a importância da decomposição de tarefas e do planejamento em sistemas de agentes autônomos alimentados por LLMs, bem como os desafios que ainda precisam ser enfrentados.

Controle de qualidade simples

from langchain_core.runnables import RunnablePassthrough
RAG_TEMPLATE = """
Você é um assistente para tarefas de resposta a perguntas. Use o seguinte peças Se você não souber a resposta, diga apenas que não sabe. Use no máximo três frases e mantenha a resposta concisa. Use no máximo três frases e mantenha a resposta concisa.
<contexto
{contexto}
 {contexto}
Responda à seguinte pergunta.
{question}""""
rag_prompt = ChatPromptTemplate.from_template(RAG_TEMPLATE)
chain = (
RunnablePassthrough.assign(context=lambda input: format_docs(input["context"]))
| rag_prompt
| rag_prompt
| StrOutputParser()
)
question = "Quais são as abordagens para a decomposição de tarefas?"
docs = vectorstore.similarity_search(question)
Execução do #
chain.invoke({"context": docs, "question": question})

A decomposição da tarefa pode ser feita por meio de (1) avisos simples usando o LLM, (2) instruções específicas da tarefa ou (3) entradas humanas. Essa abordagem ajuda a dividir tarefas grandes em subobjetivos menores e gerenciáveis para o manuseio eficiente de tarefas complexas. Ela permite que os agentes planejem com antecedência e melhorem a qualidade dos resultados finais por meio de reflexão e refinamento. Ele permite que os agentes planejem com antecedência e melhorem a qualidade dos resultados finais por meio de reflexão e refinamento.

QA com pesquisa

Por fim, nosso aplicativo de controle de qualidade com recuperação semântica (local RAG aplicativos) que podem recuperar automaticamente os fragmentos de documentos semanticamente mais semelhantes de um banco de dados vetorial com base nas perguntas do usuário:

retriever = vectorstore.as_retriever()
qa_chain = (
{"context": retriever | format_docs, "question": RunnablePassthrough()}
| rag_prompt
| model
| StrOutputParser()
)

question = "Quais são as abordagens para a decomposição de tarefas?"
qa_chain.invoke(question)

A decomposição de tarefas pode ser feita por meio de (1) simples estímulos em Modelos de Linguagem Ampla (LLM), (2) uso de instruções específicas da tarefa ou (3) com a ajuda de humanos. Esse processo envolve a divisão de grandes tarefas em subobjetivos menores e gerenciáveis para o manuseio eficiente de tarefas complexas".

resumos

Parabéns, neste ponto, você implementou totalmente um aplicativo RAG baseado na estrutura Langchain e nos modelos locais. Você pode usar o tutorial como base para substituir o modelo local e experimentar os efeitos e os recursos de diferentes modelos, ou estendê-lo ainda mais para enriquecer os recursos e a expressividade do aplicativo ou adicionar recursos mais úteis e interessantes.