Comment construire un système de chiffon d'or

Imaginez que vous construisez une IA de support client qui doit répondre à des questions sur votre produit. Parfois, il doit extraire des informations de votre documentation, tandis que d'autres fois, il doit rechercher sur le Web les dernières mises à jour. Les systèmes de chiffon agentiques sont utiles dans de tels types d'applications d'IA complexes. Considérez-les comme des assistants de recherche intelligents qui ne connaissent pas seulement votre documentation interne, mais décidez également quand aller chercher sur le Web. Dans ce guide, nous allons parcourir le processus de construction d'un système de chiffon d'assurance autonome en utilisant le framework de back de foin.

Objectifs d'apprentissage

• Sachez ce qu'est un LLM agentique et comprenez en quoi il est différent d'un système de chiffon.
• Familiarisez le cadre de la back de foin pour les applications LLM agentiques.
• Comprendre le processus de construction rapide à partir d'un modèle et apprendre à rejoindre différentes invites.
• Apprenez à créer des intérêts en utilisant ChromAdb dans la back de foin.
• Apprenez à mettre en place un système de développement local complet de l'intégration à la génération.

Cet article a été publié dans le cadre du Data Science Blogathon.

Table des matières

• Qu'est-ce qu'un LLM Agent?
  • Rag vs Rag de l'agent
• Comprendre les composants du framework Haystack
  • Que pouvez-vous construire en utilisant Haystack?
• Haystack Buildstack? Blocks
  • Composants
  • pipeline
  • nœuds
  • Graphique de connexion
• Projet RAG de question de question de question pour la physique secondaire
  • Environnement du développement
  • Document les composants du préprocement de documents Pipeline
  • Implémentez un routeur
  • Créer des modèles d'invite
  • Implémentez le graphique du pipeline de requête
  • Draw de la requête
  Conclusion
• Question fréquemment posée
Qu'est-ce qu'un LLM agentique?

Un LLM agentique est un système d'IA qui peut prendre de manière autonome des décisions et prendre des mesures en fonction de sa compréhension de la tâche. Contrairement aux LLM traditionnelles qui génèrent principalement des réponses textuelles, un LLM agentique peut en faire beaucoup plus.

Il peut penser, planifier et agir avec un minimum d'entrée humaine. Il évalue ses connaissances, reconnaissant quand elle a besoin de plus d'informations ou d'outils externes.

LLMS AGENTATIQUES Ne comptez pas sur des données statiques ou des connaissances indexées, ils décident plutôt quelles sources à faire confiance et comment rassembler les meilleures idées.

Ce type de système peut également choisir les bons outils pour le travail. Il peut décider quand il doit récupérer des documents, exécuter des calculs ou automatiser les tâches. Ce qui les distingue, c'est sa capacité à décomposer des problèmes complexes en étapes et à les exécuter indépendamment, ce qui la rend précieuse pour la recherche, l'analyse et l'automatisation du flux de travail.

rag vs rag de l'agent

Les systèmes de chiffons traditionnels suivent un processus linéaire. Lorsqu'une requête est reçue, le système identifie d'abord les éléments clés de la demande. Il recherche ensuite la base de connaissances, en parcourant des informations pertinentes qui peuvent aider à concevoir une réponse précise. Une fois les informations ou données pertinentes récupérées, le système les traite pour générer une réponse significative et contextuellement pertinente.

Vous pouvez comprendre facilement les processus par le diagramme ci-dessous.

Maintenant, un système de chiffon agentique améliore ce processus par:

• Évaluation des exigences de requête
• décider entre plusieurs sources de connaissances
• combinant potentiellement des informations provenant de différentes sources
• Prendre des décisions autonomes concernant la stratégie de réponse
• Fournir des réponses attribuées à la source

La différence clé réside dans la capacité du système à prendre des décisions intelligentes sur la façon de gérer les requêtes, plutôt que de suivre un modèle de génération de récupération fixe.

Comprendre les composants du framework de sac de foin

Haystack est un cadre open source pour construire des applications AI prêtes pour la production, LLM, des pipelines de chiffon et des systèmes de recherche. It offre un cadre puissant et flexible pour la construction d'applications LLM. Il vous permet d'intégrer des modèles de diverses plates-formes telles que HuggingFace, Openai, Cohere, Mistral et Olllama local. Vous pouvez également déployer des modèles sur des services cloud comme AWS Sagemaker, Bedrock, Azure et GCP.

Haystack fournit des magasins de documents robustes pour une gestion efficace des données. Il est également livré avec un ensemble complet d'outils d'évaluation, de surveillance et d'intégration des données qui garantissent des performances en douceur sur toutes les couches de votre application. Il a également une forte collaboration communautaire qui fait périodiquement une nouvelle intégration de services de divers fournisseurs de services.

Que pouvez-vous construire en utilisant la back de foin?

• Simple à faire progresser les chiffons sur vos données, en utilisant des techniques de récupération et de génération robustes.
• Chatbot et agents utilisant des modèles Genai à jour comme GPT-4, LLAMA3.2, Deepseek-R1.
• SYSTÈME MUTMODALE MUTMODALE générative sur des types mixtes (images, texte, audio et table) Base de connaissances.
• Extraction d'informations à partir de documents ou de création de graphiques de connaissances.

Boucons de back de foin

Haystack a deux concepts principaux pour construire des systèmes Genai LLM entièrement fonctionnels - les composants et les pipelines. Comprenons-les avec un exemple simple de chiffon sur les personnages d'anime japonais

Composants

Les composants sont les principaux éléments constitutifs de la botte de foin. Ils peuvent effectuer des tâches telles que le stockage de documents, la récupération de documents, la génération de texte et l'intégration. Haystack a de nombreux composants que vous pouvez utiliser directement après l'installation, il fournit également des API pour créer vos propres composants en écrivant une classe Python.

Il existe une collection d'intégration des entreprises partenaires et de la communauté.

Installez les bibliothèques et définissez Olllama

$ pip install haystack-ai ollama-haystack

# On you system download Ollama and install LLM

ollama pull llama3.2:3b

ollama pull nomic-embed-text


# And then start ollama server
ollama serve

Importez certains composants

from haystack import Document, Pipeline
from haystack.components.builders.prompt_builder import PromptBuilder
from haystack.components.retrievers.in_memory import InMemoryBM25Retriever
from haystack.document_stores.in_memory import InMemoryDocumentStore
from haystack_integrations.components.generators.ollama import OllamaGenerator

Créer un document et une boutique de documents

document_store = InMemoryDocumentStore()
documents = [
    Document(
        content="Naruto Uzumaki is a ninja from the Hidden Leaf Village and aspires to become Hokage."
    ),
    Document(
        content="Luffy is the captain of the Straw Hat Pirates and dreams of finding the One Piece."
    ),
    Document(
        content="Goku, a Saiyan warrior, has defended Earth from numerous powerful enemies like Frieza and Cell."
    ),
    Document(
        content="Light Yagami finds a mysterious Death Note, which allows him to eliminate people by writing their names."
    ),
    Document(
        content="Levi Ackerman is humanity’s strongest soldier, fighting against the Titans to protect mankind."
    ),
]

pipeline

Les pipelines

sont l'épine dorsale du cadre de Haystack. Ils définissent le flux de données entre les différents composants. Les pipelines sont essentiellement un graphique acyclique dirigé (DAG). Un seul composant avec plusieurs sorties peut se connecter à un autre composant unique avec plusieurs entrées.

Vous pouvez définir le pipeline par

pipe = Pipeline()

pipe.add_component("retriever", InMemoryBM25Retriever(document_store=document_store))
pipe.add_component("prompt_builder", PromptBuilder(template=template))
pipe.add_component(
    "llm", OllamaGenerator(model="llama3.2:1b", url="http://localhost:11434")
)
pipe.connect("retriever", "prompt_builder.documents")
pipe.connect("prompt_builder", "llm")

Vous pouvez visualiser le pipeline

image_param = {
    "format": "img",
    "type": "png",
    "theme": "forest",
    "bgColor": "f2f3f4",
}
pipe.show(params=image_param)

Le pipeline fournit:

• Gestion du flux de travail modulaire
• Arrangement des composants flexibles
• Débogage et surveillance faciles
• Architecture de traitement évolutive

nœuds

Les nœuds sont les unités de traitement de base qui peuvent être connectées dans un pipeline Ces nœuds sont les composants qui effectuent des tâches spécifiques.

Exemples de nœuds du pipeline ci-dessus

pipe.add_component("retriever", InMemoryBM25Retriever(document_store=document_store))
pipe.add_component("prompt_builder", PromptBuilder(template=template))
pipe.add_component(
    "llm", OllamaGenerator(model="llama3.2:1b", url="http://localhost:11434")
)

Graphique de connexion

Le ConnectionGraph définit comment les composants interagissent.

À partir du pipeline ci-dessus, vous pouvez visualiser le graphique de connexion.

image_param = {
    "format": "img",
    "type": "png",
    "theme": "forest",
    "bgColor": "f2f3f4",
}
pipe.show(params=image_param)

Le graphique de connexion du pipeline d'anime

Cette structure graphique:

• définit le flux de données entre les composants
• gère les relations d'entrée / sortie
• permet un traitement parallèle dans la mesure du possible
• crée des voies de traitement flexibles.

Maintenant, nous pouvons interroger notre base de connaissances d'anime en utilisant l'invite.

Créer un modèle d'invite

template = """
Given only the following information, answer the question.
Ignore your own knowledge.

Context:
{% for document in documents %}
    {{ document.content }}
{% endfor %}

Question: {{ query }}?
"""

Cette invite fournira une réponse en prenant des informations de la base de documents.

requête en utilisant l'invite et le retriever

query = "How Goku eliminate people?"
response = pipe.run({"prompt_builder": {"query": query}, "retriever": {"query": query}})
print(response["llm"]["replies"])

Réponse:

Ce chiffon est simple mais conceptuellement précieux pour le nouveau venu. Maintenant que nous avons compris la plupart des concepts des cadres de back de foin, nous pouvons plonger en profondeur dans notre projet principal. Si une nouvelle chose apparaît, je vais expliquer en cours de route.

Projet RAG de réponses de questions pour la physique secondaire supérieure

Nous allons construire une question de réponse basée sur les livres de physique NCERT pour les étudiants du secondaire supérieur. Il fournira des réponses à la requête en prenant des informations dans les livres NCERT, et si les informations ne sont pas là, il recherchera le Web pour obtenir ces informations.
Pour cela, j'utiliserai:

• Local Llama3.2: 3b ou Llama3.2: 1b
• chromadb pour intégrer le stockage
• Modèle de texte intégré nomique pour l'intégration locale
• DuckDuckgo Recherche pour la recherche sur le Web ou la recherche tavillante (facultative)

J'utilise un système gratuit et totalement localisé.

Configuration de l'environnement du développeur

nous configurerons un conda env python 3.12

$ pip install haystack-ai ollama-haystack

# On you system download Ollama and install LLM

ollama pull llama3.2:3b

ollama pull nomic-embed-text


# And then start ollama server
ollama serve

Installez le package nécessaire

from haystack import Document, Pipeline
from haystack.components.builders.prompt_builder import PromptBuilder
from haystack.components.retrievers.in_memory import InMemoryBM25Retriever
from haystack.document_stores.in_memory import InMemoryDocumentStore
from haystack_integrations.components.generators.ollama import OllamaGenerator

Créez maintenant un répertoire de projet nommé qagent .

document_store = InMemoryDocumentStore()
documents = [
    Document(
        content="Naruto Uzumaki is a ninja from the Hidden Leaf Village and aspires to become Hokage."
    ),
    Document(
        content="Luffy is the captain of the Straw Hat Pirates and dreams of finding the One Piece."
    ),
    Document(
        content="Goku, a Saiyan warrior, has defended Earth from numerous powerful enemies like Frieza and Cell."
    ),
    Document(
        content="Light Yagami finds a mysterious Death Note, which allows him to eliminate people by writing their names."
    ),
    Document(
        content="Levi Ackerman is humanity’s strongest soldier, fighting against the Titans to protect mankind."
    ),
]

Vous pouvez utiliser des fichiers Python simples pour le projet ou le cahier Jupyter pour le projet qu'il n'a pas d'importance. J'utiliserai un fichier python ordinaire.

Créer un fichier main.py sur la racine du projet.

Importation de bibliothèques nécessaires

• packages système
• Core Haystack Composants
• chromadb pour les composants d'intégration
• Composants olllama pour les inférences locales
• et DuckDuckgo pour la recherche sur le Web

pipe = Pipeline()

pipe.add_component("retriever", InMemoryBM25Retriever(document_store=document_store))
pipe.add_component("prompt_builder", PromptBuilder(template=template))
pipe.add_component(
    "llm", OllamaGenerator(model="llama3.2:1b", url="http://localhost:11434")
)
pipe.connect("retriever", "prompt_builder.documents")
pipe.connect("prompt_builder", "llm")

image_param = {
    "format": "img",
    "type": "png",
    "theme": "forest",
    "bgColor": "f2f3f4",
}
pipe.show(params=image_param)

pipe.add_component("retriever", InMemoryBM25Retriever(document_store=document_store))
pipe.add_component("prompt_builder", PromptBuilder(template=template))
pipe.add_component(
    "llm", OllamaGenerator(model="llama3.2:1b", url="http://localhost:11434")
)

image_param = {
    "format": "img",
    "type": "png",
    "theme": "forest",
    "bgColor": "f2f3f4",
}
pipe.show(params=image_param)

template = """
Given only the following information, answer the question.
Ignore your own knowledge.

Context:
{% for document in documents %}
    {{ document.content }}
{% endfor %}

Question: {{ query }}?
"""

Création d'une boutique de documents

La boutique de documents est la plus importante ici que nous stockons notre intégration pour la récupération, nous utilisons chromadb pour la boutique d'intégration, et comme vous pouvez le voir dans l'exemple précédent, nous utilisons un système robuste de rétrovale Démarrez le système.

La solution est une base de données vectorielle telle que Pinode, Weavate, Postgres Vector DB ou ChromAdB. J'utilise chromadb car gratuit, open-source, facile à utiliser et robuste.

query = "How Goku eliminate people?"
response = pipe.run({"prompt_builder": {"query": query}, "retriever": {"query": query}})
print(response["llm"]["replies"])

persist_path est l'endroit où vous souhaitez stocker votre intégration.

PDF Fichiers Path

$conda create --name agenticlm python=3.12

$conda activate agenticlm

Il créera une liste de fichiers à partir du dossier de données qui se compose de nos fichiers PDF.

Composants de prétraitement de document

Nous utiliserons le préprocesseur de documents intégré de Haystack tel que le nettoyant, le séparateur et le convertisseur de fichiers, puis utiliser un écrivain pour écrire les données dans le magasin.

Nettoyer: Il nettoiera l'espace supplémentaire, les lignes répétées, les lignes vides, etc. à partir des documents.

$pip install haystack-ai ollama-haystack pypdf

$pip install chroma-haystack duckduckgo-api-haystack

SPIRTER: Il divisera le document de diverses manières telles que les mots, les phrases, le paragraphe, les pages.

$md qagent # create dir

$cd qagent # change to dir

$ code .   # open folder in vscode

Convertisseur de fichiers: Il utilisera le PYPDF pour convertir le PDF en documents.

$ pip install haystack-ai ollama-haystack

# On you system download Ollama and install LLM

ollama pull llama3.2:3b

ollama pull nomic-embed-text


# And then start ollama server
ollama serve

Écrivain: Il stockera le document où vous souhaitez stocker les documents et pour les documents en double, il écrasera avec un précédent.

from haystack import Document, Pipeline
from haystack.components.builders.prompt_builder import PromptBuilder
from haystack.components.retrievers.in_memory import InMemoryBM25Retriever
from haystack.document_stores.in_memory import InMemoryDocumentStore
from haystack_integrations.components.generators.ollama import OllamaGenerator

Définissez maintenant l'intégration de l'indexation des documents.

Embedder: Nomic Embed Text

Nous utiliserons l'intégration de texte en ligne nomique qui est très efficace et inhugging face et olllama.

Avant d'exécuter votre pipeline d'indexation, ouvrez votre terminal et tapez ci-dessous pour extraire le modèle nomique-texé et LLAMA3.2: 3B du Mollama Model Store

document_store = InMemoryDocumentStore()
documents = [
    Document(
        content="Naruto Uzumaki is a ninja from the Hidden Leaf Village and aspires to become Hokage."
    ),
    Document(
        content="Luffy is the captain of the Straw Hat Pirates and dreams of finding the One Piece."
    ),
    Document(
        content="Goku, a Saiyan warrior, has defended Earth from numerous powerful enemies like Frieza and Cell."
    ),
    Document(
        content="Light Yagami finds a mysterious Death Note, which allows him to eliminate people by writing their names."
    ),
    Document(
        content="Levi Ackerman is humanity’s strongest soldier, fighting against the Titans to protect mankind."
    ),
]

et démarrez Olllama en tapant la commande Olllama Serve dans votre terminal

Composant intégré maintenant

pipe = Pipeline()

pipe.add_component("retriever", InMemoryBM25Retriever(document_store=document_store))
pipe.add_component("prompt_builder", PromptBuilder(template=template))
pipe.add_component(
    "llm", OllamaGenerator(model="llama3.2:1b", url="http://localhost:11434")
)
pipe.connect("retriever", "prompt_builder.documents")
pipe.connect("prompt_builder", "llm")

Nous utilisons OLLAMADOCUMEDEMPEDDER Composant pour intégrer des documents, mais si vous souhaitez intégrer la chaîne de texte, vous devez utiliser ollaMatextemBedder.

Création du pipeline d'indexation

Comme notre précédent exemple de chiffon de jouet, nous commencerons par initier la classe de pipeline.

image_param = {
    "format": "img",
    "type": "png",
    "theme": "forest",
    "bgColor": "f2f3f4",
}
pipe.show(params=image_param)

Maintenant, nous allons ajouter les composants à notre pipeline un par un

pipe.add_component("retriever", InMemoryBM25Retriever(document_store=document_store))
pipe.add_component("prompt_builder", PromptBuilder(template=template))
pipe.add_component(
    "llm", OllamaGenerator(model="llama3.2:1b", url="http://localhost:11434")
)

L'ajout de composants au pipeline ne se soucie pas de la commande, vous pouvez donc ajouter des composants dans n'importe quel ordre. Mais la connexion est ce qui compte.

Connexion des composants au graphique du pipeline

image_param = {
    "format": "img",
    "type": "png",
    "theme": "forest",
    "bgColor": "f2f3f4",
}
pipe.show(params=image_param)

Ici, l'ordre compte, car la façon dont vous connectez le composant indique au pipeline comment les données passeront dans le pipeline. C'est comme si cela n'a pas d'importance dans quel ordre ou d'où vous achetez vos articles de plomberie, mais comment les assembler décidera si vous obtenez votre eau ou non.

Le convertisseur convertit les PDF et les envoie pour nettoyer le nettoyage. Ensuite, le nettoyeur envoie les documents nettoyés au séparateur pour la chasse. Ces morceaux passeront ensuite aux intégrés pour la vectorisation, et les derniers intégrés remettra ces intérêts à l'écrivain pour le stockage.

comprendre! Ok, permettez-moi de vous donner un graphique visuel de l'indexation afin que vous puissiez inspecter le flux de données.

Draw Pipeline d'indexation

template = """
Given only the following information, answer the question.
Ignore your own knowledge.

Context:
{% for document in documents %}
    {{ document.content }}
{% endfor %}

Question: {{ query }}?
"""

Oui, vous pouvez facilement créer un joli graphique de sirène à partir du pipeline de back de foin.

Graphique du pipeline d'indexation

Je suppose que maintenant vous avez pleinement compris l'idée derrière le pipeline de back de foin. Remerciez votre plombier.

Implémentez un routeur

Maintenant, nous devons créer un routeur pour acheminer les données à travers un chemin différent. Dans ce cas, nous utiliserons un routeur conditionnel qui fera notre travail de routage dans certaines conditions. Le routeur conditionnel évaluera les conditions en fonction de la sortie des composants. Il dirigera le flux de données à travers différentes branches de pipeline qui permet une prise de décision dynamique. Il aura également des stratégies de secours robustes.

$ pip install haystack-ai ollama-haystack

# On you system download Ollama and install LLM

ollama pull llama3.2:3b

ollama pull nomic-embed-text


# And then start ollama server
ollama serve

Lorsque le système obtient les réponses NO_ANSWER à partir du contexte du magasin d'intégration, il ira aux outils de recherche Web pour collecter des données pertinentes à partir d'Internet.

Pour la recherche sur le Web, nous utiliserons API DuckDuckGo ou Tavily, ici j'ai utilisé DuckDuckgo.

from haystack import Document, Pipeline
from haystack.components.builders.prompt_builder import PromptBuilder
from haystack.components.retrievers.in_memory import InMemoryBM25Retriever
from haystack.document_stores.in_memory import InMemoryDocumentStore
from haystack_integrations.components.generators.ollama import OllamaGenerator

ok, la plupart des travaux lourds ont été effectués. Maintenant, il est temps pour l'ingénierie rapide

Créer des modèles d'invite

Nous utiliserons le composant d'invite de la back de foin pour construire des invites à partir du modèle

Tout d'abord, nous créerons une invite pour QA

document_store = InMemoryDocumentStore()
documents = [
    Document(
        content="Naruto Uzumaki is a ninja from the Hidden Leaf Village and aspires to become Hokage."
    ),
    Document(
        content="Luffy is the captain of the Straw Hat Pirates and dreams of finding the One Piece."
    ),
    Document(
        content="Goku, a Saiyan warrior, has defended Earth from numerous powerful enemies like Frieza and Cell."
    ),
    Document(
        content="Light Yagami finds a mysterious Death Note, which allows him to eliminate people by writing their names."
    ),
    Document(
        content="Levi Ackerman is humanity’s strongest soldier, fighting against the Titans to protect mankind."
    ),
]

Il faudra le contexte du document et essaiera de répondre à la question. Mais s'il ne trouve pas de contexte pertinent dans les documents, il répondra à No_answer.

Maintenant, dans la deuxième invite après avoir obtenu le NO_ANSWER à partir du LLM, le système utilisera les outils de recherche Web pour rassembler le contexte à partir d'Internet.

modèle d'invite de DuckDuckgo

pipe = Pipeline()

pipe.add_component("retriever", InMemoryBM25Retriever(document_store=document_store))
pipe.add_component("prompt_builder", PromptBuilder(template=template))
pipe.add_component(
    "llm", OllamaGenerator(model="llama3.2:1b", url="http://localhost:11434")
)
pipe.connect("retriever", "prompt_builder.documents")
pipe.connect("prompt_builder", "llm")

Il facilitera le système pour aller à la recherche Web et essayer de répondre à la requête.

Création d'invite à l'aide d'invite-builder à partir de Haystack

image_param = {
    "format": "img",
    "type": "png",
    "theme": "forest",
    "bgColor": "f2f3f4",
}
pipe.show(params=image_param)

Nous utiliserons la menuiseuse de Haystack Invite pour rejoindre les branches de l'invite.

pipe.add_component("retriever", InMemoryBM25Retriever(document_store=document_store))
pipe.add_component("prompt_builder", PromptBuilder(template=template))
pipe.add_component(
    "llm", OllamaGenerator(model="llama3.2:1b", url="http://localhost:11434")
)

Implémentez le pipeline de requête

Le pipeline de requête intégrera les ressources contextuelles de collecte de requêtes à partir des intégres et répondront à notre requête à l'aide de LLM ou d'outil de recherche Web.

Il est similaire au pipeline d'indexation.

Pipeline de lancement

image_param = {
    "format": "img",
    "type": "png",
    "theme": "forest",
    "bgColor": "f2f3f4",
}
pipe.show(params=image_param)

Ajout de composants au pipeline de requête

template = """
Given only the following information, answer the question.
Ignore your own knowledge.

Context:
{% for document in documents %}
    {{ document.content }}
{% endfor %}

Question: {{ query }}?
"""

Ici, pour la génération LLM, nous utilisons le composant OllaMagenerator pour générer des réponses en utilisant LLAMA3.2: 3B ou 1B ou tout ce que vous aimez avec les appels d'outils.

Connecter tous les composants ensemble pour le flux de requête et la génération de réponses

query = "How Goku eliminate people?"
response = pipe.run({"prompt_builder": {"query": query}, "retriever": {"query": query}})
print(response["llm"]["replies"])

en résumé de la connexion ci-dessus:

1. L'intégration du Text_embedder envoyé à la requête du retriever.
2. Le Retriever envoie des données au document de Prompt_Builder.
3. Invite Builder Accédez à la menuiseuse pour rejoindre d'autres invites.
4. Invite Joiner transmet des données au LLM pour la génération.
5. Les réponses de LLM vont aux routeurs pour vérifier si la réponse a no_answer ou non.If no_answer alors il ira au module de recherche Web.
6. La recherche Web envoie les données à une invite de recherche Web comme une requête.
7. Documents de recherche Web Envoi des données aux documents de recherche Web.
8. L'invite de recherche Web envoie les données à l'invite Joiner.
9. et le menuisier invité enverra les données au LLM pour la génération de réponses.

Pourquoi ne pas voir par vous-même?

Draw Graphique du pipeline de requête

$conda create --name agenticlm python=3.12

$conda activate agenticlm

Graphique de requête

Je sais que c'est un graphique énorme mais cela vous montrera exactement ce qui se passe sous le ventre de la bête.

Il est maintenant temps de profiter du fruit de notre travail acharné.

Créez une fonction pour la requête facile.

$ pip install haystack-ai ollama-haystack

# On you system download Ollama and install LLM

ollama pull llama3.2:3b

ollama pull nomic-embed-text


# And then start ollama server
ollama serve

C'est une fonction simple simple pour la génération de réponses.

exécutez maintenant votre script principal pour indexer le livre de physique NCERT

from haystack import Document, Pipeline
from haystack.components.builders.prompt_builder import PromptBuilder
from haystack.components.retrievers.in_memory import InMemoryBM25Retriever
from haystack.document_stores.in_memory import InMemoryDocumentStore
from haystack_integrations.components.generators.ollama import OllamaGenerator

Il s'agit d'un travail unique, après l'indexation, vous devez commenter cette ligne, sinon il commencera à réindexer les livres.

et le bas du fichier, nous écrivons notre code de pilote pour la requête

document_store = InMemoryDocumentStore()
documents = [
    Document(
        content="Naruto Uzumaki is a ninja from the Hidden Leaf Village and aspires to become Hokage."
    ),
    Document(
        content="Luffy is the captain of the Straw Hat Pirates and dreams of finding the One Piece."
    ),
    Document(
        content="Goku, a Saiyan warrior, has defended Earth from numerous powerful enemies like Frieza and Cell."
    ),
    Document(
        content="Light Yagami finds a mysterious Death Note, which allows him to eliminate people by writing their names."
    ),
    Document(
        content="Levi Ackerman is humanity’s strongest soldier, fighting against the Titans to protect mankind."
    ),
]

MCQ sur la résistivité des connaissances du livre

Une autre question qui n'est pas dans le livre

pipe = Pipeline()

pipe.add_component("retriever", InMemoryBM25Retriever(document_store=document_store))
pipe.add_component("prompt_builder", PromptBuilder(template=template))
pipe.add_component(
    "llm", OllamaGenerator(model="llama3.2:1b", url="http://localhost:11434")
)
pipe.connect("retriever", "prompt_builder.documents")
pipe.connect("prompt_builder", "llm")

sortie

essayons une autre question.

image_param = {
    "format": "img",
    "type": "png",
    "theme": "forest",
    "bgColor": "f2f3f4",
}
pipe.show(params=image_param)

donc, ça marche! Nous pouvons utiliser plus de données, de livres ou de PDF pour l'intégration qui générera des réponses plus conscientes contextuelles. De plus, les LLM tels que GPT-4O, Claude d'Anthropic ou d'autres LLM cloud feront le travail encore mieux.

Conclusion

Notre système de chiffon agentique démontre la flexibilité et la robustesse du cadre de back de foin avec sa puissance de combinaison de composants et de pipelines. Ce chiffon peut être rendu prêt pour la production en se déplaçant sur la plate-forme de service Web et en utilisant également un LLM mieux payé tel que OpenAI et NTHROPIC. Vous pouvez créer une interface utilisateur en utilisant un spa Web Streamlit ou React pour une meilleure expérience utilisateur.

Vous pouvez trouver tout le code utilisé dans l'article, ici.

Les plats clés

• Les systèmes de chiffon agentiques fournissent des réponses plus intelligentes et flexibles que le chiffon traditionnel.
• L'architecture de pipeline de Haystack permet des flux de travail complexes et modulaires.
Les routeurs
• permettent une prise de décision dynamique dans la génération de réponse.
• Les graphiques de connexion fournissent des interactions de composants flexibles et maintenables.
• L'intégration de plusieurs sources de connaissances améliore la qualité de la réponse.

Le média montré dans cet article ne appartient pas à l'analyse vidhya et est utilisé à la discrétion de l'auteur .

question fréquemment posée

Q1. Comment le système gère-t-il les requêtes inconnues?

a. Le système utilise son composant de routeur pour se replier automatiquement à la recherche Web lorsque les connaissances locales sont insuffisantes, garantissant une couverture complète.

Q2. Quels avantages l'offre l'architecture du pipeline?

a. L'architecture du pipeline permet un développement modulaire, des tests faciles et une disposition des composants flexibles, ce qui rend le système maintenable et extensible.

Q3. Comment le graphique de connexion améliore-t-il la fonctionnalité du système?

a. Le graphique de connexion permet des flux de données complexes et un traitement parallèle, améliorant l'efficacité du système et la flexibilité dans la gestion de différents types de requêtes.

Q4. Puis-je utiliser d'autres API LLM?

a. Oui, il est très facile d'installer simplement le package d'intégration nécessaire pour l'API LLM respective tel que les gemini, l'anthropique et le grogne, et l'utiliser avec vos touches API.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!