Applications RAG natives avec DeepSeek R1 et Ollama

bref

Ce document explique comment utiliser le DeepSeek R1 et Ollama créer des applications RAG (Retrieval Augmented Generation) localisées. C'est aussi un excellent moyen de tirer le meilleur parti de l'application Création d'une application locale RAG avec LangChain Le supplément.

Nous démontrerons le processus complet de mise en œuvre à l'aide d'exemples, y compris le traitement de documents, le stockage de vecteurs, l'appel de modèles et d'autres étapes clés. Ce tutoriel utilise Profondeur de l'eau-R1 1.5B comme modèle linguistique de base. Étant donné que les différents modèles ont leurs propres caractéristiques et performances, les lecteurs peuvent choisir d'autres modèles appropriés à mettre en œuvre en fonction des besoins réels de l'entreprise. RAG Le système.

Note : Ce document contient des extraits de code et des explications détaillées. Le code complet est disponible à l'adresse suivante carnet de notes .

préparation préliminaire

Tout d'abord, nous devons télécharger Ollama et configurer l'environnement.

Le dépôt GitHub d'Ollama fournit une description détaillée, que nous résumons brièvement comme suit.

Step1, téléchargez Ollama.

téléchargement et double-cliquez pour lancer l'application Ollama.

Étape 2, vérifier l'installation.

Sur la ligne de commande, tapez ollamaSi le message suivant apparaît, Ollama a été installé avec succès.

Étape 3, tirer le modèle.

• À partir de la ligne de commande, voir Liste de modèles Ollama répondre en chantant Liste des modèles d'intégration de texte Tirer le modèle. Dans ce tutoriel, nous prenons le deepseek-r1:1.5b répondre en chantant nomic-embed-text Exemple.
  • entrée de la ligne de commande ollama pull deepseek-r1:1.5bExtraction de grands modèles linguistiques génériques à source ouverte deepseek-r1:1.5b(Il se peut que le processus soit lent lors de l'extraction des modèles. En cas d'erreur de tirage, vous pouvez réintroduire la commande de tirage)
  • entrée de la ligne de commande ollama pull nomic-embed-text tirer Modèle d'intégration de texte nomic-embed-text.
• Lorsque l'application est en cours d'exécution, tous les modèles se trouvent automatiquement dans l'application localhost:11434 Sur le départ.
• Notez que votre choix de modèle doit prendre en compte les capacités de votre matériel local, la taille de la mémoire vidéo de référence pour ce tutoriel. CPU Memory > 8GB.

Étape 4 : déploiement du modèle.

La fenêtre de ligne de commande exécute la commande suivante pour déployer le modèle.

ollama run deepseek-r1:1.5b

Il est également possible d'exécuter le modèle de déploiement directement à partir de la ligne de commande, par exemple ollama run deepseek-r1:1.5b.

Notez que les étapes suivantes ne sont pas nécessaires si vous souhaitez uniquement déployer les modèles DeepSeek R1 à l'aide d'Ollama.

Étape 5, installer les dépendances.

# langchain_community
pip install langchain langchain_community

# Chroma
pip install langchain_chroma

# Ollama
pip install langchain_ollama

Ceci étant dit, commençons à construire une solution étape par étape basée sur LangChain, Ollama, et DeepSeek R1 Les étapes de la mise en œuvre sont décrites en détail ci-dessous. Les étapes de la mise en œuvre sont décrites en détail ci-dessous.

1. chargement des documents

Chargez des documents PDF et découpez-les en blocs de texte de taille appropriée.

from langchain_community.document_loaders import PDFPlumberLoader
file = "DeepSeek_R1.pdf"
# Load the PDF
loader = PDFPlumberLoader(file)
docs = loader.load()
from langchain.text_splitter import RecursiveCharacterTextSplitter
text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=0)
all_splits = text_splitter.split_documents(docs)

2. initialisation du stockage vectoriel

Utilisez la base de données Chroma pour stocker les vecteurs de documents et configurez le modèle d'intégration fourni par Ollama.

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)

3. construction d'expressions en chaîne

Mettre en place des modèles et des repères pour construire des chaînes de traitement.

from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_ollama import ChatOllama
model = ChatOllama(
model="deepseek-r1:1.5b",
)
prompt = ChatPromptTemplate.from_template(
"Summarize the main themes in these retrieved docs: {docs}"
)
# 将传入的文档转换成字符串的形式
def format_docs(docs):
return "\n\n".join(doc.page_content for doc in docs)
chain = {"docs": format_docs} | prompt | model | StrOutputParser()
question = "What is the purpose of the DeepSeek project?"
docs = vectorstore.similarity_search(question)
chain.invoke(docs)

4. l'assurance qualité avec recherche

Intégrer les fonctions de recherche et de questions-réponses.

from langchain_core.runnables import RunnablePassthrough
RAG_TEMPLATE = """
You are an assistant for question-answering tasks. Use the following pieces of retrieved context to answer the question. If you don't know the answer, just say that you don't know. Use three sentences maximum and keep the answer concise.
<context>
{context}
</context>
Answer the following question:
{question}"""
rag_prompt = ChatPromptTemplate.from_template(RAG_TEMPLATE)
retriever = vectorstore.as_retriever()
qa_chain = (
{"context": retriever | format_docs, "question": RunnablePassthrough()}
| rag_prompt
| model
| StrOutputParser()
)
question = "What is the purpose of the DeepSeek project?"
# Run
qa_chain.invoke(question)

résumés

Ce tutoriel explique comment construire une application RAG localisée en utilisant DeepSeek R1 et Ollama. Nous obtenons une fonctionnalité complète en quatre étapes principales :

1. traitement des dossiers Les documents PDF sont chargés à l'aide du PDFPlumberLoader et le RecursiveCharacterTextSplitter permet de découper le texte en morceaux de taille appropriée.
2. stockage vectoriel Système de stockage vectoriel utilisant la base de données Chroma et le modèle d'intégration d'Ollama pour fournir une base pour l'extraction ultérieure de similarités.
3. Construction de la chaîne Les résultats de l'évaluation de l'efficacité des systèmes de gestion de l'information et de la communication sont présentés dans le tableau ci-dessous.
4. Réalisation du RAG Le système est capable de répondre aux questions de l'utilisateur en fonction du contenu du document.

Grâce à ce tutoriel, vous pouvez rapidement construire votre propre système RAG local et le personnaliser pour l'améliorer en fonction de vos besoins réels. Il est recommandé d'essayer différents modèles et configurations de paramètres dans la pratique pour en tirer le meilleur parti.

Note : En utilisant des outils tels que streamlit ou FastAPI, il est possible de déployer une application RAG locale en tant que service web, ce qui permet d'élargir l'éventail des scénarios d'application.

Le référentiel fournit également app.py vous pouvez exécuter le fichier directement pour démarrer le service web. Documentation sur le service web Construire un système RAG avec DeepSeek R1 et Ollama. Note : Exécutez le service Ollama avant d'exécuter ce code.

La page de dialogue se présente comme suit :