Construire un système de chiffon pour la prise de décision intelligente dans les organisations

Dans l’environnement commercial au rythme rapide d’aujourd’hui, les organisations sont inondées de données qui stimulent les décisions, optimise les opérations et maintient la compétitivité. Cependant, l'extraction d'informations exploitables de ces données reste un obstacle important. Un système de génération (RAG) de la récupération (RAG), lorsqu'il est intégré à l'IA d'agence, relève ce défi non seulement en récupérant des informations pertinentes, mais aussi en traitement et en fournissant des informations contextuelles en temps réel. Cette combinaison permet aux entreprises de créer des agents intelligents qui interrogent de manière autonome des ensembles de données, adapter et extraire des informations sur les caractéristiques des produits, les intégrations et les opérations.

En fusionnant le chiffon avec une IA agentique, les entreprises peuvent améliorer la prise de décision et convertir les données dispersées en renseignements précieux. Ce blog explore le processus de construction d'un pipeline de chiffons avec une IA agentique, offrant des informations techniques et des exemples de code pour permettre la prise de décision intelligente dans les organisations.

Objectifs d'apprentissage

• Apprenez à extraire et à gratter automatiquement les données pertinentes à partir de plusieurs sources Web à l'aide de Python et d'outils de grattage, formant les bases de toute plate-forme d'intelligence de l'entreprise.
• Apprenez à structurer et à traiter les données grattées dans des informations précieuses et exploitables en extraitant des points clés tels que les fonctionnalités du produit, les intégrations et les étapes de dépannage en utilisant des techniques axées sur l'IA.
• Apprenez à intégrer RAG avec la récupération de documents et la génération du langage naturel pour construire un système de requête intelligent capable de fournir des réponses contextuelles à partir de vastes ensembles de données.
• Comprendre comment construire un système d'IA agentique qui combine le grattage des données, l'extraction des connaissances et le traitement des requêtes en temps réel, permettant aux entreprises d'extraire des informations exploitables de manière autonome.
• Gardez une compréhension de la façon de faire évoluer et de déployer un tel système à l'aide de plates-formes cloud et d'architectures distribuées, en garantissant qu'il peut gérer efficacement de grands ensembles de données et des charges de requête élevées.

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

Table des matières

• Extraction de données à l'aide de BFS et grattant les données
• Extraction des informations sur l'agent AI
• RETRAVALAGE-AUGMENT PIPELINE implémentation
• Déplacement et a posé des questions
• CONCURICATION
• Fréquemment des questions

Conclusion

Extraction de données à l'aide de BFS et grattant les données

La première étape de la construction d'un système de chiffon robuste pour le renseignement de l'entreprise est la collecte des données nécessaires. Étant donné que les données peuvent provenir de diverses sources Web, le gratter et l'organiser efficacement est essentiel. Une technique efficace pour découvrir et collecter les pages pertinentes est la recherche de largeur d'abord (BFS). BFS nous aide à découvrir récursivement des liens à partir d'une page principale, élargissant progressivement la recherche à des niveaux plus profonds. Cela garantit que nous rassemblons toutes les pages pertinentes sans submerger le système avec des données inutiles.

Dans cette section, nous examinerons comment extraire des liens à partir d'un site Web à l'aide de BFS, suivi par le grattage du contenu de ces pages. À l'aide de BFS, nous traversons systématiquement des sites Web, collectons des données et créons un ensemble de données significatif pour le traitement dans un pipeline de chiffons.

Étape 1: Extraction de liaison à l'aide de BFS

Pour commencer, nous devons collecter tous les liens pertinents à partir d'un site Web donné. À l'aide de BFS, nous pouvons explorer les liens sur la page d'accueil, et à partir de là, suivre les liens sur d'autres pages récursivement jusqu'à une profondeur spécifiée. Cette méthode garantit que nous captions toutes les pages nécessaires qui pourraient contenir les données de l'entreprise concernées, telles que les caractéristiques du produit, les intégrations ou d'autres détails clés.

Le code ci-dessous effectue l'extraction des liens à partir d'une URL de démarrage à l'aide de BFS. Il commence par récupérer la page principale, extrait tous les liens (& lt; a & gt; balises avec les attributs HREF), puis suit ces liens vers des pages suivantes, élargissant récursivement la recherche en fonction d'une limite de profondeur donnée.

import requests
from bs4 import BeautifulSoup
from collections import deque

# Function to extract links using BFS
def bfs_link_extraction(start_url, max_depth=3):
    visited = set()  # To track visited links
    queue = deque([(start_url, 0)])  # Queue to store URLs and current depth
    all_links = []

    while queue:
        url, depth = queue.popleft()

        if depth > max_depth:
            continue

        # Fetch the content of the URL
        try:
            response = requests.get(url)
            soup = BeautifulSoup(response.content, 'html.parser')

            # Extract all links in the page
            links = soup.find_all('a', href=True)
            for link in links:
                full_url = link['href']
                if full_url.startswith('http') and full_url not in visited:
                    visited.add(full_url)
                    queue.append((full_url, depth + 1))
                    all_links.append(full_url)
        except requests.exceptions.RequestException as e:
            print(f"Error fetching {url}: {e}")

    return all_links

# Start the BFS from the homepage
start_url = 'https://www.example.com'  # Replace with the actual homepage URL
all_extracted_links = bfs_link_extraction(start_url)
print(f"Extracted {len(all_extracted_links)} links.")

Voici le code pour effectuer l'extraction des liens:

Nous maintenons une file d'attente pour suivre les URL à visiter avec leurs profondeurs correspondantes, assurant une traversée efficace. Un ensemble visité est utilisé pour empêcher la révision de la même URL plusieurs fois. Pour chaque URL, nous utilisons BeautifulSoup pour analyser le HTML et extraire tous les liens (balises avec les attributs HREF). Le processus utilise la traversée BFS, récupérant récursivement le contenu de chaque URL, extrait les liaisons et explorant davantage jusqu'à atteindre la limite de profondeur. Cette approche garantit que nous explorons efficacement le Web sans redondance.

sortie

Extracted 1500 links.

Ce code publie une liste de liens extraits du site Web, jusqu'à la profondeur spécifiée.

La sortie montre que le système a trouvé et collecté 1500 liens sur le site Web de départ et ses pages liées jusqu'à une profondeur de 3. Vous remplaceriez https://www.example.com par votre URL cible réelle. Vous trouverez ci-dessous la capture d'écran de sortie du code d'origine. Des informations sensibles ont été masquées pour maintenir l'intégrité.

Étape 2: gratter les données des liens extraits

Une fois que nous avons extrait les liens pertinents à l'aide de BFS, l'étape suivante consiste à gratter le contenu de ces pages. Nous rechercherons des informations clés telles que les caractéristiques du produit, les intégrations et toutes les autres données pertinentes qui nous aideront à créer un ensemble de données structuré pour le système RAG.

Dans cette étape, nous parcourons la liste des liens extraits et rayons le contenu des clés, tels que le titre de la page et son contenu principal. Vous pouvez ajuster ce code pour gratter les points de données supplémentaires au besoin (par exemple, caractéristiques du produit, tarification ou informations sur la FAQ).

import requests
from bs4 import BeautifulSoup
from collections import deque

# Function to extract links using BFS
def bfs_link_extraction(start_url, max_depth=3):
    visited = set()  # To track visited links
    queue = deque([(start_url, 0)])  # Queue to store URLs and current depth
    all_links = []

    while queue:
        url, depth = queue.popleft()

        if depth > max_depth:
            continue

        # Fetch the content of the URL
        try:
            response = requests.get(url)
            soup = BeautifulSoup(response.content, 'html.parser')

            # Extract all links in the page
            links = soup.find_all('a', href=True)
            for link in links:
                full_url = link['href']
                if full_url.startswith('http') and full_url not in visited:
                    visited.add(full_url)
                    queue.append((full_url, depth + 1))
                    all_links.append(full_url)
        except requests.exceptions.RequestException as e:
            print(f"Error fetching {url}: {e}")

    return all_links

# Start the BFS from the homepage
start_url = 'https://www.example.com'  # Replace with the actual homepage URL
all_extracted_links = bfs_link_extraction(start_url)
print(f"Extracted {len(all_extracted_links)} links.")

Pour chaque URL de la liste, nous envoyons une demande HTTP pour récupérer le contenu de la page et l'analyser en utilisant BeautifulSoup pour extraire le titre et le contenu principal. Nous stockons les données extraites dans une liste de dictionnaires, chacune contenant l'URL, le titre et le contenu. Enfin, nous enregistrons les données grattées dans un fichier JSON, garantissant qu'elle est disponible pour le traitement ultérieur dans le pipeline de chiffons. Ce processus garantit une collecte et un stockage efficaces des données pertinentes pour une utilisation ultérieure.

sortie

La sortie de ce code serait un fichier JSON enregistré (Strotd_data.json) contenant les données grattées des liens. Un exemple de la structure de données pourrait ressembler à ceci:

Extracted 1500 links.

Ce fichier JSON contient les URL, les titres et le contenu pour chacune des pages que nous avons grattées. Ces données structurées peuvent désormais être utilisées pour un traitement ultérieur, telles que la génération d'intégration et la réponse aux questions dans le système de chiffon. Vous trouverez ci-dessous la capture d'écran de sortie du code d'origine. Des informations sensibles ont été masquées pour maintenir l'intégrité.

Automatisation de l'extraction d'informations avec l'agent AI

Dans la section précédente, nous avons couvert le processus de gratte des liens et de collection de contenu Web brut à l'aide d'une stratégie de recherche (BFS) de largeur (BFS). Une fois les données nécessaires grattées, nous avons besoin d'un système robuste pour organiser et extraire des informations exploitables de ce contenu brut. C'est là que l'agent AI intervient: en traitant les données grattées, il structure automatiquement les informations en sections significatives.

Dans cette section, nous nous concentrons sur la façon dont l'agent IA extrait les informations pertinentes des produits des données grattées, garantissant qu'elle est prête pour la consommation des parties prenantes. Nous décomposons les étapes clés impliquées, du chargement des données pour le traiter et de l'enregistrement enfin des résultats dans un format structuré.

Étape 1: Chargement des données grattées

La première étape de ce processus consiste à charger le contenu gratté brut dans notre système. Comme nous l'avons vu précédemment, les données grattées sont stockées au format JSON, et chaque entrée comprend une URL et un contenu associé. Nous devons nous assurer que ces données sont dans un format approprié pour le traitement de l'IA.

Snippet de code:

import requests
from bs4 import BeautifulSoup
from collections import deque

# Function to extract links using BFS
def bfs_link_extraction(start_url, max_depth=3):
    visited = set()  # To track visited links
    queue = deque([(start_url, 0)])  # Queue to store URLs and current depth
    all_links = []

    while queue:
        url, depth = queue.popleft()

        if depth > max_depth:
            continue

        # Fetch the content of the URL
        try:
            response = requests.get(url)
            soup = BeautifulSoup(response.content, 'html.parser')

            # Extract all links in the page
            links = soup.find_all('a', href=True)
            for link in links:
                full_url = link['href']
                if full_url.startswith('http') and full_url not in visited:
                    visited.add(full_url)
                    queue.append((full_url, depth + 1))
                    all_links.append(full_url)
        except requests.exceptions.RequestException as e:
            print(f"Error fetching {url}: {e}")

    return all_links

# Start the BFS from the homepage
start_url = 'https://www.example.com'  # Replace with the actual homepage URL
all_extracted_links = bfs_link_extraction(start_url)
print(f"Extracted {len(all_extracted_links)} links.")

Ici, nous chargeons l'intégralité de l'ensemble de données en mémoire à l'aide de la bibliothèque JSON intégrée de Python. Chaque entrée de l'ensemble de données contient l'URL de la source et un champ Text_content, qui contient le texte gratté brut. Ce contenu est ce que nous allons traiter dans les prochaines étapes.

Étape 2: Extraction du contenu de texte brut

Ensuite, nous réduisons le jeu de données pour extraire le Text_content pertinent pour chaque entrée. Cela garantit que nous ne travaillons qu'avec des entrées valides qui contiennent le contenu nécessaire. Des entrées non valides ou incomplètes sont ignorées pour maintenir l'intégrité du processus.

Snippet de code:

Extracted 1500 links.

À ce stade, la variable Input_text contient le contenu de texte brut que nous enverrons au modèle AI pour un traitement ultérieur. Il est crucial que nous assurions la présence des clés nécessaires avant de traiter chaque entrée.

Étape 3: Envoi de données à l'agent AI pour le traitement

Après avoir extrait le contenu brut, nous l'envoyons au modèle AI agentique pour une extraction structurée. Nous interagissons avec l'API GROQ pour demander des informations structurées basées sur des invites prédéfinies. Le modèle d'IA traite le contenu et renvoie des informations organisées qui couvrent les aspects clés tels que les capacités de produit, les intégrations et les étapes de dépannage.

Snippet de code:

import json

# Function to scrape and extract data from the URLs
def scrape_data_from_links(links):
    scraped_data = []

    for link in links:
        try:
            response = requests.get(link)
            soup = BeautifulSoup(response.content, 'html.parser')

            # Example: Extract 'title' and 'content' (modify according to your needs)
            title = soup.find('title').get_text()
            content = soup.find('div', class_='content').get_text()  # Adjust selector

            # Store the extracted data
            scraped_data.append({
                'url': link,
                'title': title,
                'content': content
            })
        except requests.exceptions.RequestException as e:
            print(f"Error scraping {link}: {e}")

    return scraped_data

# Scrape data from the extracted links
scraped_contents = scrape_data_from_links(all_extracted_links)

# Save scraped data to a JSON file
with open('/content/scraped_data.json', 'w') as outfile:
    json.dump(scraped_contents, outfile, indent=4)

print("Data scraping complete.")

Ici, le code initie un appel API à GROQ, envoyant la charge utile Input_text et dans le cadre de la charge utile des messages. Le message système instruit le modèle AI sur la tâche exacte à effectuer, tandis que le message de l'utilisateur fournit le contenu à traiter. Nous utilisons les paramètres de température, max_tokens et top_p pour contrôler l'aléatoire et la longueur de la sortie générée.

Configuration de l'appel de l'API:

• Modèle: Spécifie le modèle à utiliser. Dans ce cas, un modèle de langue est choisi pour s'assurer qu'il peut gérer les données textuelles et générer des réponses.
• Température: contrôle la créativité des réponses. Une valeur plus élevée conduit à des réponses plus créatives, tandis que des valeurs plus faibles les rendent plus déterministes.
• max_tokens: Définit la longueur maximale de la réponse générée.
• top_p: détermine la distribution de probabilité cumulative pour la sélection des jetons, contrôlant la diversité dans la réponse.

Étape 4: Traitement et collecte des résultats

Une fois que le modèle AI traite le contenu, il renvoie des morceaux d'informations structurées. Nous collectons et concatenons ces morceaux pour créer un ensemble complet de résultats, garantissant qu'aucune donnée n'est perdue et que la sortie finale est terminée.

Snippet de code:

import requests
from bs4 import BeautifulSoup
from collections import deque

# Function to extract links using BFS
def bfs_link_extraction(start_url, max_depth=3):
    visited = set()  # To track visited links
    queue = deque([(start_url, 0)])  # Queue to store URLs and current depth
    all_links = []

    while queue:
        url, depth = queue.popleft()

        if depth > max_depth:
            continue

        # Fetch the content of the URL
        try:
            response = requests.get(url)
            soup = BeautifulSoup(response.content, 'html.parser')

            # Extract all links in the page
            links = soup.find_all('a', href=True)
            for link in links:
                full_url = link['href']
                if full_url.startswith('http') and full_url not in visited:
                    visited.add(full_url)
                    queue.append((full_url, depth + 1))
                    all_links.append(full_url)
        except requests.exceptions.RequestException as e:
            print(f"Error fetching {url}: {e}")

    return all_links

# Start the BFS from the homepage
start_url = 'https://www.example.com'  # Replace with the actual homepage URL
all_extracted_links = bfs_link_extraction(start_url)
print(f"Extracted {len(all_extracted_links)} links.")

Cet extrait de code concaténe le contenu de chaque morceau à la variable pm_point , ce qui se traduit par un ensemble complet et structuré d'informations. Il extrait ces idées dans un format que les parties prenantes peuvent facilement consommer ou utiliser pour une analyse plus approfondie. Vous trouverez ci-dessous la capture d'écran de sortie du code d'origine, avec des informations sensibles masquées pour maintenir l'intégrité.

Étape 5: Gestion des erreurs et maintien de l'intégrité des données

Lors du traitement, il y a toujours la possibilité de rencontrer des erreurs, telles que des problèmes de contenu ou de réseau incomplets. En utilisant des mécanismes de gestion des erreurs, nous nous assurons que le processus se poursuit en douceur pour toutes les entrées valides.

Snippet de code:

Extracted 1500 links.

Ce bloc d'essai à l'exception attrape et enregistre toutes les erreurs, garantissant que le système continue de traiter d'autres entrées. Si une entrée spécifique provoque un problème, le système le marque pour examen sans interrompre le processus global.

Étape 6: Enregistrer les données traitées

Une fois que l'IA traite le contenu et renvoie des informations structurées, la dernière étape consiste à enregistrer ces données pour une utilisation ultérieure. Nous rémettons les résultats structurés à un fichier JSON, garantissant que chaque entrée a ses propres informations traitées pour une analyse plus approfondie.

Snippet de code:

import json

# Function to scrape and extract data from the URLs
def scrape_data_from_links(links):
    scraped_data = []

    for link in links:
        try:
            response = requests.get(link)
            soup = BeautifulSoup(response.content, 'html.parser')

            # Example: Extract 'title' and 'content' (modify according to your needs)
            title = soup.find('title').get_text()
            content = soup.find('div', class_='content').get_text()  # Adjust selector

            # Store the extracted data
            scraped_data.append({
                'url': link,
                'title': title,
                'content': content
            })
        except requests.exceptions.RequestException as e:
            print(f"Error scraping {link}: {e}")

    return scraped_data

# Scrape data from the extracted links
scraped_contents = scrape_data_from_links(all_extracted_links)

# Save scraped data to a JSON file
with open('/content/scraped_data.json', 'w') as outfile:
    json.dump(scraped_contents, outfile, indent=4)

print("Data scraping complete.")

Ce code stocke efficacement les données traitées et permet un accès facile plus tard. Il enregistre chaque entrée avec ses points structurés respectifs, ce qui rend la récupération et l'analyse des informations extraites simples.

sortie

Après avoir exécuté le code ci-dessus, le fichier JSON traité contiendra les points extraits pour chaque entrée. Les champs pm_points conserveront les informations structurées liées aux capacités du produit, aux intégrations, aux étapes de dépannage, et plus encore, prêtes à une analyse ou à une intégration plus approfondie dans vos workflows.

[
    {
        "url": "https://www.example.com/page1",
        "title": "Page 1 Title",
        "content": "This is the content of the first page. It contains 
        information about integrations and features."
    },
    {
        "url": "https://www.example.com/page2",
        "title": "Page 2 Title",
        "content": "Here we describe the functionalities of the product. 
        It includes various use cases and capabilities."
    }
]

Vous trouverez ci-dessous la capture d'écran de sortie du code d'origine. Des informations sensibles ont été masquées pour maintenir l'intégrité.

Implémentation du pipeline de génération de récupération de la récupération

Dans la section précédente, nous nous sommes concentrés sur l'extraction de données à partir des pages Web et les convertissant en formats structurés comme JSON. Nous avons également mis en œuvre des techniques pour extraire et nettoyer les données pertinentes, nous permettant de générer un ensemble de données prêt à une analyse plus approfondie.

En s'appuyant sur que, dans cette section, nous mettrons en œuvre un pipeline de génération (RAG) (RAG) de récupération, qui combine la récupération de documents et la génération de modèles de langues pour répondre aux questions basées sur les informations extraites.

En intégrant les données structurées que nous avons précédemment grattées et traitées, ce pipeline de chiffons récupérera non seulement les morceaux de document les plus pertinents, mais générera également des réponses précises et perspicaces basées sur ce contexte.

Étape 1: Configuration de l'environnement

Pour commencer, installons toutes les dépendances nécessaires pour le pipeline de chiffon:

import requests
from bs4 import BeautifulSoup
from collections import deque

# Function to extract links using BFS
def bfs_link_extraction(start_url, max_depth=3):
    visited = set()  # To track visited links
    queue = deque([(start_url, 0)])  # Queue to store URLs and current depth
    all_links = []

    while queue:
        url, depth = queue.popleft()

        if depth > max_depth:
            continue

        # Fetch the content of the URL
        try:
            response = requests.get(url)
            soup = BeautifulSoup(response.content, 'html.parser')

            # Extract all links in the page
            links = soup.find_all('a', href=True)
            for link in links:
                full_url = link['href']
                if full_url.startswith('http') and full_url not in visited:
                    visited.add(full_url)
                    queue.append((full_url, depth + 1))
                    all_links.append(full_url)
        except requests.exceptions.RequestException as e:
            print(f"Error fetching {url}: {e}")

    return all_links

# Start the BFS from the homepage
start_url = 'https://www.example.com'  # Replace with the actual homepage URL
all_extracted_links = bfs_link_extraction(start_url)
print(f"Extracted {len(all_extracted_links)} links.")

Ces packages sont cruciaux pour intégrer le traitement des documents, la vectorisation et les modèles OpenAI au sein de Langchain. JQ est un processeur JSON léger, tandis que Langchain sert de cadre central pour la construction de pipelines de modèle de langue. Langchain-Openai facilite l'intégration de modèles OpenAI comme GPT, et Langchain-chroma propose des magasins vectoriels à base de chrome pour gérer les incorporations de documents.

De plus, nous utilisons des transformateurs de phrase pour générer des intérêts de texte avec des modèles de transformateurs pré-formés, permettant une gestion et une récupération de documents efficaces.

Étape 2: Chargement des données extraites

Maintenant, nous allons charger les données structurées qui ont été extraites et traitées dans la section précédente à l'aide de JSONLoader. Ces données, par exemple, auraient pu être grattées des pages Web en tant que JSON structuré, avec des paires de valeurs clés pertinentes pour des sujets ou des questions spécifiques.

Extracted 1500 links.

Dans cette étape, les données qui ont été déjà extraites (contenant peut-être des capacités de produit, des intégrations et des fonctionnalités) est chargée pour un traitement ultérieur.

Étape 3: Diviser les documents en morceaux plus petits

Maintenant que nous avons les données brutes, nous utilisons le RecursiVeCaracterTextSt Plitter pour diviser le document en morceaux plus petits. Cela garantit qu'aucun morceau ne dépasse la limite de jeton du modèle de langue.

import json

# Function to scrape and extract data from the URLs
def scrape_data_from_links(links):
    scraped_data = []

    for link in links:
        try:
            response = requests.get(link)
            soup = BeautifulSoup(response.content, 'html.parser')

            # Example: Extract 'title' and 'content' (modify according to your needs)
            title = soup.find('title').get_text()
            content = soup.find('div', class_='content').get_text()  # Adjust selector

            # Store the extracted data
            scraped_data.append({
                'url': link,
                'title': title,
                'content': content
            })
        except requests.exceptions.RequestException as e:
            print(f"Error scraping {link}: {e}")

    return scraped_data

# Scrape data from the extracted links
scraped_contents = scrape_data_from_links(all_extracted_links)

# Save scraped data to a JSON file
with open('/content/scraped_data.json', 'w') as outfile:
    json.dump(scraped_contents, outfile, indent=4)

print("Data scraping complete.")

Le RecursiveCharAtteTtextSsplitter divise un document en segments plus petits, garantissant que les chevauchements de morceaux sont préservés pour une meilleure compréhension contextuelle. Le paramètre Chunk_Size détermine la taille de chaque morceau, tandis que Chunk_overlap garantit que des informations importantes sont conservées sur les morceaux adjacents. De plus, add_start_index aide à maintenir l'ordre du document en incluant un index, ce qui permet un suivi facile de l'emplacement de chaque morceau dans le document d'origine.

Étape 4: générer des intégres pour les morceaux de document

Maintenant, nous convertissons chaque morceau de texte en intégres en utilisant le SentenTenTransformateur. Ces intérêts représentent la signification du texte dans un espace vectoriel à haute dimension, qui est utile pour rechercher et récupérer des documents pertinents plus tard.

[
    {
        "url": "https://www.example.com/page1",
        "title": "Page 1 Title",
        "content": "This is the content of the first page. It contains 
        information about integrations and features."
    },
    {
        "url": "https://www.example.com/page2",
        "title": "Page 2 Title",
        "content": "Here we describe the functionalities of the product. 
        It includes various use cases and capabilities."
    }
]

SentenTansformrer est utilisé pour générer des intégres pour des morceaux de texte, créant des représentations vectorielles denses qui capturent des informations sémantiques. La fonction Embed_Documents traite plusieurs documents et renvoie leurs intégres, tandis que ENGED_QUERY génère des intégres pour les requêtes utilisateur. Chroma, un magasin vectoriel, gère ces intérêts et permet une récupération efficace en fonction de la similitude, permettant une correspondance de documents ou de requête rapide et précise.

Étape 5: Configuration du retriever

Maintenant, nous configurons le retriever. Ce composant recherche les morceaux de texte les plus pertinents en fonction de la requête d'un utilisateur. Il récupère les morceaux de document les plus similaires dans la requête.

import requests
from bs4 import BeautifulSoup
from collections import deque

# Function to extract links using BFS
def bfs_link_extraction(start_url, max_depth=3):
    visited = set()  # To track visited links
    queue = deque([(start_url, 0)])  # Queue to store URLs and current depth
    all_links = []

    while queue:
        url, depth = queue.popleft()

        if depth > max_depth:
            continue

        # Fetch the content of the URL
        try:
            response = requests.get(url)
            soup = BeautifulSoup(response.content, 'html.parser')

            # Extract all links in the page
            links = soup.find_all('a', href=True)
            for link in links:
                full_url = link['href']
                if full_url.startswith('http') and full_url not in visited:
                    visited.add(full_url)
                    queue.append((full_url, depth + 1))
                    all_links.append(full_url)
        except requests.exceptions.RequestException as e:
            print(f"Error fetching {url}: {e}")

    return all_links

# Start the BFS from the homepage
start_url = 'https://www.example.com'  # Replace with the actual homepage URL
all_extracted_links = bfs_link_extraction(start_url)
print(f"Extracted {len(all_extracted_links)} links.")

• Le Retriever utilise la recherche de similitude pour trouver les morceaux les plus pertinents du magasin vectoriel.
• Le paramètre k = 6 signifie qu'il renverra les 6 premiers morceaux les plus pertinents pour la requête.

Étape 6: Création du modèle d'invite

Ensuite, nous créons un modèle d'invite qui formara l'entrée du modèle de langue. Ce modèle comprend à la fois le contexte (morceaux récupérés) et la requête de l'utilisateur, guidant le modèle pour générer une réponse basée uniquement sur le contexte fourni.

Extracted 1500 links.

• Le ChatPromptTemplate forme l'entrée du modèle d'une manière qui souligne la nécessité que la réponse soit basée uniquement sur le contexte donné.
• {Context} sera remplacé par les morceaux de texte pertinents, et {Question} sera remplacé par la requête de l'utilisateur.

Étape 7: Configuration du modèle de langue

Dans cette étape, nous initialisons le modèle Openai GPT. Ce modèle générera des réponses basées sur le contexte structuré fourni par le retriever.

import json

# Function to scrape and extract data from the URLs
def scrape_data_from_links(links):
    scraped_data = []

    for link in links:
        try:
            response = requests.get(link)
            soup = BeautifulSoup(response.content, 'html.parser')

            # Example: Extract 'title' and 'content' (modify according to your needs)
            title = soup.find('title').get_text()
            content = soup.find('div', class_='content').get_text()  # Adjust selector

            # Store the extracted data
            scraped_data.append({
                'url': link,
                'title': title,
                'content': content
            })
        except requests.exceptions.RequestException as e:
            print(f"Error scraping {link}: {e}")

    return scraped_data

# Scrape data from the extracted links
scraped_contents = scrape_data_from_links(all_extracted_links)

# Save scraped data to a JSON file
with open('/content/scraped_data.json', 'w') as outfile:
    json.dump(scraped_contents, outfile, indent=4)

print("Data scraping complete.")

• Nous initialisons le modèle Chatopenai, qui traitera l'invite et générera une réponse.
• Nous utilisons un modèle plus petit, «GPT-4O-MINI», pour un traitement efficace, bien que des modèles plus grands puissent être utilisés pour des tâches plus complexes.

Étape 8: Construire le pipeline de chiffon

Ici, nous intégrons tous les composants (retriever, prompt, llm) dans un pipeline de chiffon cohésif. Ce pipeline prendra la requête, récupérera le contexte pertinent, le passera à travers le modèle et générera une réponse.

[
    {
        "url": "https://www.example.com/page1",
        "title": "Page 1 Title",
        "content": "This is the content of the first page. It contains 
        information about integrations and features."
    },
    {
        "url": "https://www.example.com/page2",
        "title": "Page 2 Title",
        "content": "Here we describe the functionalities of the product. 
        It includes various use cases and capabilities."
    }
]

• RunnablePasshrough garantit que la requête est transmise directement à l'invite.
• StroutputParser est utilisé pour nettoyer et formater la sortie du modèle au format de chaîne.

Étape 9: Tester le pipeline de chiffon

Enfin, nous testons le pipeline avec diverses requêtes utilisateur. Pour chaque requête, le système récupère des morceaux de document pertinents, les transmet à travers le modèle de langue et génère une réponse.

import json

# Load the scraped JSON file containing the web data
with open('/content/scraped_contents_zluri_all_links.json', 'r') as file:
    data = json.load(file)

• Le système itère à travers chaque requête, invoquant le pipeline et imprimant la réponse générée.
• Pour chaque requête, le modèle traite le contexte récupéré et fournit une réponse fondée sur le contexte.

Vous trouverez ci-dessous des captures d'écran de la sortie de chiffon du code d'origine. Des informations sensibles ont été masquées pour maintenir l'intégrité.

En combinant le grattage Web, l'extraction de données et les techniques de génération avancées de récupération (RAG), nous avons créé un cadre puissant et évolutif pour l'intelligence de l'entreprise. La première étape d'extraction des liens et de gratter les données garantit que nous collectons des informations pertinentes et à jour sur le Web. La deuxième section se concentre sur la sélection de détails spécifiques liés au produit, ce qui facilite la catégorisation et le traitement efficacement des données.

Enfin, le tir de RAG nous permet de répondre dynamiquement aux requêtes complexes en récupérant et en synthétisant des informations contextuelles à partir de vastes ensembles de données. Ensemble, ces composants forment une configuration complète qui peut être utilisée pour construire une plate-forme agentique capable de rassembler, de traiter et de fournir des informations exploitables sur les entreprises. Ce cadre pourrait servir de base au développement de systèmes de renseignement avancés, permettant aux organisations d'automatiser l'analyse concurrentielle, de surveiller les tendances du marché et de rester informés de leur industrie.

Déploiement et mise à l'échelle

Une fois le système de renseignement de l'entreprise construit, l'étape suivante consiste à le déployer et à l'étendre pour une utilisation en production. Vous pouvez déployer le système sur des plates-formes cloud comme AWS ou GCP pour la flexibilité et l'évolutivité, ou opter pour une solution sur site si la confidentialité des données est une priorité. Pour rendre le système plus convivial, envisagez de créer une API ou une interface utilisateur simple qui permet aux utilisateurs d'interagir avec la plate-forme et de récupérer les informations sans effort. Au fur et à mesure que le système commence à gérer des ensembles de données plus grands et des charges de requête plus élevées, il est essentiel de mettre à l'échelle efficacement.

Ceci peut être réalisé en tirant parti des magasins de vecteurs distribués et en optimisant le processus de récupération, garantissant que le pipeline reste réactif et rapide même sous une utilisation intensive. Avec les bonnes techniques d'infrastructure et d'optimisation en place, la plate-forme agentique peut se développer pour prendre en charge les opérations à grande échelle, permettant des idées en temps réel et en maintenant un avantage concurrentiel dans l'intelligence de l'entreprise.

Conclusion

Dans le monde actuel axé sur les données, l'extraction des informations exploitables à partir des données de l'entreprise non structurées est cruciale. Un système de génération (RAG) (RAG) de la récupération combine le grattage des données, l'extraction de pointeurs et l'interrogation intelligente pour créer une plate-forme puissante pour l'intelligence de l'entreprise. En organisant des informations clés et en permettant aux réponses en temps réel et spécifiques au contexte, les systèmes de chiffons autorisent la prise de décision intelligente dans les organisations, aidant les entreprises à prendre des décisions adaptables et adaptables.

Cette solution évolutive se développe avec vos besoins, en manipulant des requêtes complexes et des ensembles de données plus grands tout en maintenant la précision. Avec la bonne infrastructure, cette plate-forme axée sur l'IA devient une pierre angulaire pour les opérations plus intelligentes, permettant aux organisations d'exploiter leurs données, de rester compétitives et de stimuler l'innovation grâce à la prise de décision intelligente dans les organisations.

Les plats clés

• Lien d'extraction et de grattage Web Améliorez l'intelligence de l'entreprise en permettant une collecte de données automatique et efficace à partir de plusieurs sources avec un minimum d'effort.
• Extraire les points clés des points de données transforme le contenu non structuré en connaissances organisées et exploitables, renforçant l'intelligence de l'entreprise pour les idées axées sur l'IA.
• combinant un chiffon avec un magasin vectoriel personnalisé et un retriever optimisé permet des réponses intelligentes et conscientes pour une meilleure prise de décision.
• Les solutions basées sur le cloud et les magasins de vecteurs distribués garantissent une mise à l'échelle efficace, la gestion des ensembles de données plus importants et des charges de requête sans perte de performances.
• Le pipeline de chiffon traite les requêtes en temps réel, offrant des informations précises et à la demande directement à partir de la base de connaissances.

bonus: Tous les codes discutés ici sont mis à disposition dans le lien suivant. Un total de 4 cahiers sont disponibles, avec des noms auto-explicatifs pour chaque ordinateur portable. N'hésitez pas à explorer, développer et révolutionner l'entreprise!

Les questions fréquemment posées

q 1. Quel est le but de l'utilisation de la génération (RAG) (RAG) de la récupération dans cette configuration?

a. RAG améliore la capacité des modèles d'IA à fournir des réponses compatibles en matière de contexte en combinant la récupération d'informations avec une IA générative. Il permet une requête plus intelligente de grands ensembles de données, ce qui facilite la récupération de réponses précises et pertinentes plutôt que de simplement effectuer une recherche de mots clés de base.

q 2. Quels outils et bibliothèques sont nécessaires pour créer le système décrit dans le blog?

a. Les principaux outils et bibliothèques utilisés incluent Python, BeautifulSoup pour le grattage Web, Langchain pour gérer la récupération de documents, les modèles OpenAI pour le traitement du langage naturel et le chroma pour le stockage des documents vectorisés. Ces composants fonctionnent ensemble pour créer une plate-forme de renseignement complète de l'entreprise.

q 3. Comment le processus d'extraction du pointeur fonctionne-t-il dans ce système?

a. L'extraction du pointeur consiste à identifier des informations spécifiques à partir du contenu gratté, telles que les caractéristiques du produit, les intégrations et les conseils de dépannage. Les données sont traitées à l'aide d'un système invite, qui organise les informations en informations structurées et exploitables. Ceci est réalisé en utilisant une combinaison de modèles AI et d'invites personnalisées.

Q 4. Comment les agents RAG et IA améliorent-ils l'intelligence de l'entreprise?

a. Les agents du chiffon et de l'IA améliorent Société de l'entreprise en automatisant la récupération, le traitement et l'analyse des données, permettant aux entreprises d'extraire des informations réelles et exploitables.

Q5. Pourquoi le grattage des données est-il important pour l'intelligence de l'entreprise?

a. Le grattage des données aide à construire un système solide de renseignement de l'entreprise en collectant et en structurant des informations précieuses à partir de plusieurs sources pour la prise de décision éclairée.

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

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!