In der heutigen schnelllebigen Gesch?ftsumgebung werden Organisationen mit Daten überschwemmt, die Entscheidungen vorantreiben, den Betrieb optimieren und die Wettbewerbsf?higkeit aufrechterhalten. Das Extrahieren von umsetzbaren Erkenntnissen aus diesen Daten bleibt jedoch eine signifikante Hürde. Ein RAG-System (Abruf-Augmented Generation), wenn er in die Agentic AI integriert ist, befasst sich mit dieser Herausforderung, indem sie nicht nur relevante Informationen abrufen, sondern auch kontextbezogene Erkenntnisse in Echtzeit verarbeiten und liefern. Diese Kombination erm?glicht es Unternehmen, intelligente Agenten zu erstellen, die Datens?tze autonom abfragen, sich an die Produktfunktionen, Integrationen und Vorg?nge anpassen und extrahieren.

Durch das Zusammenführen von Lappen mit Agentic AI k?nnen Unternehmen die Entscheidungsfindung verbessern und verstreute Daten in wertvolle Intelligenz umwandeln. In diesem Blog wird der Prozess des Aufbaus einer Lag-Pipeline mit Agentic AI untersucht, die technische Erkenntnisse und Codebeispiele bietet, um die intelligente Entscheidungsfindung in Organisationen zu st?rken.

Lernziele

• Erfahren Sie, wie Sie mithilfe von Python- und Scraping -Tools automatisch relevante Daten aus mehreren Webquellen extrahieren und abkratzen und die Grundlage für jede Unternehmens -Intelligenz -Plattform bilden.
• Erfahren Sie, wie Sie Daten in wertvolle, umsetzbare Erkenntnisse strukturieren und verarbeiten k?nnen, indem wichtige Punkte wie Produktfunktionalit?ten, Integrationen und Fehlerbehebungsschritte mithilfe von AI-gesteuerten Techniken extrahiert werden.
• Erfahren Sie, wie Sie Lappen mit Abrufen von Dokumenten und natürlicher Sprache integrieren, um ein intelligentes Abfragesystem aufzubauen, das kontextbezogene Antworten aus riesigen Datens?tzen liefern kann.
• Verstehen Sie, wie Sie ein Agenten-KI-System erstellen, das Datenkratzen, Wissensextraktion und Echtzeitverarbeitung kombiniert und es Unternehmen erm?glicht, umsetzbare Erkenntnisse autonom zu extrahieren.
• Verst?ndnis für die Skalierung und Bereitstellung eines solchen Systems mithilfe von Cloud -Plattformen und verteilten Architekturen, um sicherzustellen, dass gro?e Datens?tze und hohe Abfragen effektiv behandelt werden k?nnen.

Dieser Artikel wurde als Teil des Data Science -Blogathon ver?ffentlicht.

Table of contents

• Data Extraction Using BFS and Scraping the Data
• Automating Information Extraction with AI Agent
• Retrieval-Augmented Generation Pipeline Implementation
• Deployment and Scaling
• Conclusion
• Frequently Asked Questions

Datenextraktion mit BFS und Abkratzen der Daten

Der erste Schritt beim Aufbau eines robusten Lappensystems für Unternehmensintelligenz besteht darin, die erforderlichen Daten zu sammeln. Da Daten aus verschiedenen Webquellen stammen k?nnen, ist das Scraping und Organisieren von ihnen effizient von entscheidender Bedeutung. Eine wirksame Technik zum Entdecken und Sammeln der entsprechenden Seiten ist die Breadth-First Search (BFS). BFS hilft uns, die Links ab einer Hauptseite rekursiv zu entdecken und die Suche nach und nach auf tiefere Ebenen zu erweitern. Dies stellt sicher, dass wir alle relevanten Seiten sammeln, ohne das System mit unn?tigen Daten zu überw?ltigen.

In diesem Abschnitt werden wir untersuchen, wie Sie Links von einer Website mithilfe von BFS extrahieren k?nnen, gefolgt von dem Abkratzen der Inhalte von diesen Seiten. Mit BFS durchqueren wir systematisch Websites, sammeln Daten und erstellen einen aussagekr?ftigen Datensatz für die Verarbeitung in einer Rag -Pipeline.

Schritt 1: Link -Extraktion mit BFS

Zu Beginn müssen wir alle relevanten Links von einer bestimmten Website sammeln. Mit BFS k?nnen wir die Links auf der Homepage untersuchen und von dort aus Links auf anderen Seiten bis zu einer bestimmten Tiefe befolgen. Diese Methode stellt sicher, dass wir alle erforderlichen Seiten erfassen, die m?glicherweise die relevanten Unternehmensdaten enthalten, z. B. Produktfunktionen, Integrationen oder andere Schlüsseldetails.

Der folgende Code führt die Link -Extraktion aus einer Start -URL mithilfe von BFS aus. Es beginnt mit dem Abholen der Hauptseite, extrahiert alle Links (& lt; a & gt; Tags mit HREF -Attributen) und folgt dann diese Links zu nachfolgenden Seiten, um die Suche rekursiv auf der Grundlage einer bestimmten Tiefengrenze zu erweitern.

Hier ist der Code zur Ausführung der Link -Extraktion:

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.")

Wir behalten eine Warteschlange bei, um die URLs zusammen mit ihren entsprechenden Tiefen zu verfolgen, um eine effiziente Durchführung zu gew?hrleisten. Ein besuchter Set wird verwendet, um zu verhindern, dass die gleiche URL mehrmals überprüft wird. Für jede URL verwenden wir BeautifulSoup, um die HTML zu analysieren und alle Links zu extrahieren (Tags mit HREF -Attributen). Der Prozess verwendet das BFS -Traversal, holt rekursiv den Inhalt der einzelnen URL, extrahiert Links und erforscht weiter, bis sie die Tiefengrenze erreicht. Dieser Ansatz stellt sicher, dass wir das Web ohne Redundanz effizient untersuchen.

Ausgabe

Dieser Code gibt eine Liste von Links aus, die von der Website extrahiert wurden, bis zur angegebenen Tiefe.

Extracted 1500 links.

Die Ausgabe zeigt, dass das System 1500 Links von der Startwebsite und seinen verknüpften Seiten bis zu einer Tiefe von 3. gefunden hat. Unten finden Sie den Ausgabebuchscreenshot des ursprünglichen Code. Sensible Informationen wurden maskiert, um die Integrit?t aufrechtzuerhalten.

Schritt 2: Kratzen von Daten aus extrahierten Links

abkratzen

Sobald wir die relevanten Links mithilfe von BFS extrahiert haben, besteht der n?chste Schritt darin, den Inhalt auf diesen Seiten abzukratzen. Wir werden nach Schlüsselinformationen wie Produktfunktionen, Integrationen und anderen relevanten Daten suchen, die uns helfen, einen strukturierten Datensatz für das Lag -System zu erstellen.

In diesem Schritt k?nnen wir die Liste extrahierter Links und Schlüsselinhalte durchlaufen, z. B. den Titel der Seite und dessen Hauptinhalt. Sie k?nnen diesen Code anpassen, um zus?tzliche Datenpunkte nach Bedarf zu kratzen (z. B. Produktfunktionen, Preisgestaltung oder FAQ -Informationen).

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.")

Für jede URL in der Liste senden wir eine HTTP -Anfrage, um den Inhalt der Seite abzurufen und sie mit BeautifulSoup zu analysieren, um den Titel und den Hauptinhalt zu extrahieren. Wir speichern die extrahierten Daten in einer Liste von W?rterbüchern, die jeweils die URL, den Titel und den Inhalt enthalten. Schlie?lich speichern wir die abgekratzten Daten in eine JSON -Datei, um sicherzustellen, dass sie für die sp?tere Verarbeitung in der Rag -Pipeline verfügbar sind. Dieser Prozess sorgt für eine effiziente Erfassung und Speicherung relevanter Daten für die weitere Verwendung.

Ausgabe

Die Ausgabe dieses Codes w?re eine gespeicherte JSON -Datei (Scraped_data.json), die die abgekratzten Daten aus den Links enth?lt. Ein Beispiel für die Datenstruktur k?nnte so aussehen:

Extracted 1500 links.

Diese JSON -Datei enth?lt die URLs, Titel und Inhalte für jede der von uns abgekratzten Seiten. Diese strukturierten Daten k?nnen nun für die weitere Verarbeitung verwendet werden, z. B. für die Einbettung von Erzeugung und Fragen im Lappensystem. Unten finden Sie den Ausgabebuchscreenshot des ursprünglichen Code. Sensible Informationen wurden maskiert, um die Integrit?t aufrechtzuerhalten.

Automatisierung der Informationsextraktion mit AI Agent

Im vorherigen Abschnitt haben wir den Prozess des Abkratzens von Links und zum Sammeln von RAW-Webinhalten mithilfe einer BREFTH-First-Such-Strategie (BREADTH-First Search) behandelt. Sobald die erforderlichen Daten abgekratzt sind, ben?tigen wir ein robustes System zum Organisieren und Extrahieren von umsetzbaren Erkenntnissen aus diesem Rohinhalt. Hier tritt die Agenten -KI ein: Durch Verarbeitung der abgekratzten Daten strukturiert sie die Informationen automatisch in aussagekr?ftige Abschnitte.

In diesem Abschnitt konzentrieren wir uns darauf, wie agenten -KI relevante Produktinformationen aus den abgekratzten Daten extrahiert und sicherstellen, dass sie für den Verbrauch der Stakeholder bereit sind. Wir werden die wichtigsten Schritte aufschlüsseln, vom Laden der Daten bis zur Verarbeitung und schlie?lich speichern die Ergebnisse in einem strukturierten Format.

Schritt 1: Abkrapattdaten

laden

Der erste Schritt in diesem Vorgang besteht darin, den RAW -Scrap -Inhalt in unser System zu laden. Wie wir bereits gesehen haben, werden die abgekratzten Daten im JSON -Format gespeichert, und jeder Eintrag enth?lt eine URL und den zugeh?rigen Inhalt. Wir müssen sicherstellen, dass sich diese Daten in einem geeigneten Format für die KI befinden.

Code -Snippet:

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.")

Hier laden wir den gesamten Datensatz mithilfe der integrierten JSON-Bibliothek von Python in den Speicher. Jeder Eintrag im Datensatz enth?lt die URL der Quelle und ein Feld text_content, das den rohen abkratzten Text enth?lt. Dieser Inhalt ist das, was wir in den n?chsten Schritten verarbeiten werden.

Schritt 2: Extrahieren des Rohtextinhalts

Als n?chstes iterieren wir den Datensatz durch, um den entsprechenden Text_Content für jeden Eintrag zu extrahieren. Dies stellt sicher, dass wir nur mit gültigen Eintr?gen arbeiten, die den erforderlichen Inhalt enthalten. Ungültige oder unvollst?ndige Eintr?ge werden übersprungen, um die Integrit?t des Prozesses aufrechtzuerhalten.

Code -Snippet:

Extracted 1500 links.

Zu diesem Zeitpunkt enth?lt die Variable input_text den Rohtextinhalt, den wir zur weiteren Verarbeitung an das AI -Modell senden. Es ist entscheidend, dass wir das Vorhandensein der erforderlichen Schlüssel vor der Verarbeitung jedes Eintrags sicherstellen.

Schritt 3: Daten an AI -Agenten zur Verarbeitung

senden

Nachdem wir den Rohinhalt extrahiert haben, senden wir ihn für die strukturierte Extraktion an das Agentic AI -Modell. Wir interagieren mit der GROQ -API, um strukturierte Erkenntnisse basierend auf vordefinierten Eingabeaufforderungen anzufordern. Das KI -Modell verarbeitet den Inhalt und gibt organisierte Informationen zurück, die wichtige Aspekte wie Produktfunktionen, Integrationen und Fehlerbehebungsschritte abdecken.

Code -Snippet:

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.")

Hier initiiert der Code einen API -Aufruf an COQ und sendet den input_text und die Anweisungen als Teil der Nachrichtennutzlast. Die Systemmeldung weist das KI -Modell in der genauen Aufgabe an, w?hrend die Benutzernachricht den zu verarbeitenden Inhalt bereitstellt. Wir verwenden die Parameter Temperatur, max_tokens und TOP_P, um die Zuf?lligkeit und L?nge der erzeugten Ausgabe zu steuern.

API -Aufrufkonfiguration:

• Modell: Gibt das zu verwendende Modell an. In diesem Fall wird ein Sprachmodell ausgew?hlt, um sicherzustellen, dass es Textdaten verarbeiten und Antworten generieren kann.
• Temperatur: steuert die Kreativit?t der Antworten. Ein h?herer Wert führt zu kreativeren Antworten, w?hrend niedrigere Werte sie deterministischer machen.
• max_tokens: Legt die maximale L?nge der erzeugten Antwort fest.
• top_p: bestimmt die kumulative Wahrscheinlichkeitsverteilung für die Token -Selektion, wobei die Vielfalt in der Antwort kontrolliert.

Schritt 4: Verarbeitung und Sammeln von Ergebnissen

Sobald das KI -Modell den Inhalt verarbeitet, gibt es Stücke strukturierter Informationen zurück. Wir sammeln und verkettet diese Stücke, um einen vollst?ndigen Satz von Ergebnissen zu erstellen, um sicherzustellen, dass keine Daten verloren gehen und die endgültige Ausgabe abgeschlossen ist.

Code -Snippet:

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.")

Dieser Code -Snippet verkettet den Inhalt von jedem Chunk mit der Variablen pm_points , was zu einem vollst?ndigen, strukturierten Einblickssatz führt. Es extrahiert diese Erkenntnisse in einem Format, das die Stakeholder für die weitere Analyse problemlos konsumieren oder verwenden k?nnen. Im Folgenden finden Sie den Ausgabe -Screenshot des ursprünglichen Codes, wobei sensible Informationen maskiert sind, um die Integrit?t aufrechtzuerhalten.

Schritt 5: Fehlerbehandlung und Aufrechterhaltung der Datenintegrit?t

W?hrend der Verarbeitung besteht immer die M?glichkeit, Fehler wie unvollst?ndige Inhalte oder Netzwerkprobleme zu begegnen. Durch die Verwendung von Fehlerbehandlungsmechanismen stellen wir sicher, dass der Prozess für alle gültigen Eintr?ge reibungslos fortgesetzt wird.

Code -Snippet:

Extracted 1500 links.

Dieser Try-Except-Block-Fang und protokolliert alle Fehler und stellt sicher, dass das System weiterhin andere Eintr?ge verarbeitet. Wenn ein bestimmter Eintrag ein Problem verursacht, markiert das System es zur überprüfung, ohne den Gesamtprozess zu stoppen.

Schritt 6: Speichern der verarbeiteten Daten

Nachdem der KI den Inhalt verarbeitet und strukturierte Erkenntnisse zurückgibt, speichert der letzte Schritt diese Daten für die sp?tere Verwendung. Wir schreiben die strukturierten Ergebnisse in eine JSON -Datei zurück und stellen sicher, dass jeder Eintrag für weitere Analysen seine eigenen verarbeiteten Informationen gespeichert hat.

Code -Snippet:

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.")

Dieser Code speichert die verarbeiteten Daten effizient und erm?glicht einen einfachen Zugriff sp?ter. Es spart jeden Eintrag mit seinen jeweiligen strukturierten Punkten, wodurch das Abrufen und die Analyse der extrahierten Informationen einfach ist.

Ausgabe

Nach dem Ausführen des oben genannten Codes enth?lt die verarbeitete JSON -Datei die extrahierten Punkte für jeden Eintrag. Die Felder PM_POINTS werden die strukturierten Informationen zu Produktfunktionen, Integrationen, Fehlerbehebungsschritten und mehr zur weiteren Analyse oder Integration in Ihre Workflows enthalten.

[
    {
        "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."
    }
]

unten finden Sie den Ausgabe -Screenshot des ursprünglichen Code. Sensible Informationen wurden maskiert, um die Integrit?t aufrechtzuerhalten.

Pipeline-Implementierung von Abrufen-Abruf-Generation

Im vorherigen Abschnitt haben wir uns auf die Datenextraktion von Webseiten konzentriert und sie in strukturierte Formate wie JSON konvertiert. Wir haben auch Techniken implementiert, um relevante Daten zu extrahieren und zu reinigen, sodass wir einen Datensatz generieren k?nnen, der für eine tiefere Analyse bereit ist.

Aufbauend in diesem Abschnitt werden wir eine Pipeline (Abruf-Augmented-Generation) implementieren, die das Abrufen von Dokumenten und die Erzeugung des Sprachmodells kombiniert, um Fragen basierend auf den extrahierten Informationen zu beantworten.

Durch die Integration der zuvor abgekratzten und verarbeiteten strukturierten Daten ruft diese RAG -Pipeline nicht nur die relevantesten Dokumentbrocken ab, sondern generiert auch genaue, aufschlussreiche Antworten basierend auf diesem Kontext.

Schritt 1: Einrichten der Umgebung

Lassen Sie uns zun?chst alle notwendigen Abh?ngigkeiten für die Lag -Pipeline installieren:

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.")

Diese Pakete sind entscheidend für die Integration der Modelle zur Verarbeitung, Vektorisierung und OpenAI in Langchain. JQ ist ein leichter JSON -Prozessor, w?hrend Langchain als Kernrahmen für den Aufbau von Sprachmodellpipelines dient. Langchain-OpenAI erleichtert die Integration von OpenAI-Modellen wie GPT, und Langchain-Chroma bietet Chroma-basierte Vektorstores für die Verwaltung von Dokumentenbettendings.

Zus?tzlich verwenden wir Satztransformer, um Texteinbettungen mit vorgebildeten Transformatormodellen zu generieren, wodurch ein effizientes Dokumentenhandhabung und -Antrag erm?glicht werden.

Schritt 2: Laden der extrahierten Daten

Jetzt laden wir die strukturierten Daten, die im vorherigen Abschnitt mit JSONLoader extrahiert und verarbeitet wurden. Diese Daten k?nnten beispielsweise als strukturierter JSON von Webseiten mit Schlüsselwertpaaren für bestimmte Themen oder Fragen relevant sein.

.

Extracted 1500 links.

In diesem Schritt werden die zuvor extrahierten Daten (m?glicherweise Produktfunktionen, Integrationen und Merkmale) zur weiteren Verarbeitung geladen.

Schritt 3: Teilen Sie die Dokumente in kleinere Stücke

auf

Jetzt, da wir die Rohdaten haben, verwenden wir den recursivecharactertextSplitter, um das Dokument in kleinere Stücke zu unterteilen. Dies stellt sicher, dass kein einzelner Teil die Token -Grenze des Sprachmodells überschreitet.

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.")

Der recursivecharactertextSplitter unterteilt ein Dokument in kleinere Segmente, um sicherzustellen, dass Chunk -überschneidungen für ein besseres kontextbezogenes Verst?ndnis erhalten bleiben. Der Parameter Chunk_Size bestimmt die Gr??e jedes Chunk, w?hrend Chunk_Overlap sicherstellt, dass wichtige Informationen über benachbarte Stücke erhalten bleiben. Zus?tzlich hilft add_start_index bei der Aufrechterhaltung der Reihenfolge des Dokuments durch Einbeziehung eines Index und erm?glicht eine einfache Verfolgung, wo jeder Chunk im Originaldokument stammt.

Schritt 4: Erzeugen von Einbettungen für Dokumentbrocken

Nun konvertieren wir jeden Textblock in Einbettungen mit dem Sentcetransformer. Diese Einbettungen repr?sentieren die Bedeutung des Textes in einem hochdimensionalen Vektorraum, der nützlich ist, um relevante Dokumente sp?ter zu durchsuchen und abzurufen.

[
    {
        "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."
    }
]

SateTransformer wird verwendet, um Einbettung für Textbrocken zu generieren, wodurch dichte Vektordarstellungen erstellen, die semantische Informationen erfassen. Die Funktion embod_documents verarbeitet mehrere Dokumente und gibt ihre Einbettungen zurück, w?hrend Emboden_Query Einbettung für Benutzeranfragen generiert. Chroma, ein Vektorspeicher, verwaltet diese Einbettungen und erm?glicht ein effizientes Abrufen auf der Grundlage der ?hnlichkeit, sodass ein schnelles und genaues Dokument oder Abfrageanpassungen erm?glicht werden.

Schritt 5: Einrichten des Retriever

Jetzt konfigurieren wir den Retriever. Diese Komponente sucht nach den relevantesten Textbrocken basierend auf der Abfrage eines Benutzers. Es ruft die obersten ?hnlichen Dokumentenbrocken zur Abfrage ab.

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.")

• Der Retriever verwendet ?hnlichkeitssuche, um die relevantesten Stücke aus dem Vektor Store zu finden.
• Der Parameter k = 6 bedeutet, dass er die Top 6 Brocken zurückgibt, die für die Abfrage am relevantesten sind.

Schritt 6: Erstellen der Eingabeaufforderung Vorlage

Als n?chstes erstellen wir eine schnelle Vorlage, die die Eingabe für das Sprachmodell formatiert. Diese Vorlage enth?lt sowohl den Kontext (abgerufene Brocken) als auch die Abfrage des Benutzers, wobei das Modell so leitet, dass eine Antwort nur auf dem bereitgestellten Kontext basiert.

Extracted 1500 links.

Die ChatpromptTemplate formatiert die Eingabe für das Modell auf eine Weise
• {context} wird durch die entsprechenden Textbrocken ersetzt und {Frage} wird durch die Abfrage des Benutzers ersetzt.
Schritt 7: Einrichten des Sprachmodells

In diesem Schritt initialisieren wir das OpenAI -GPT -Modell. Dieses Modell generiert Antworten basierend auf dem vom Retriever bereitgestellten strukturierten Kontext.

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.")

Wir initialisieren das Chatopenai -Modell, das die Eingabeaufforderung verarbeitet und eine Antwort generiert.

• Wir verwenden ein kleineres Modell, ?GPT-4O-Mini“, für eine effiziente Verarbeitung, obwohl gr??ere Modelle für komplexere Aufgaben verwendet werden k?nnten.
Schritt 8: Konstruktion der Lag -Pipeline

Hier integrieren wir alle Komponenten (retriever, prompt, llm) in eine zusammenh?ngende Lappenpipeline. Diese Pipeline nimmt die Abfrage an, ruft den relevanten Kontext ab, passt sie durch das Modell und generiert eine Antwort.

[
    {
        "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."
    }
]

RunnablePass Through stellt sicher, dass die Abfrage direkt an die Eingabeaufforderung übergeben wird.

• stroutputParser wird verwendet, um die Ausgabe aus dem Modell in ein Zeichenfolgenformat zu reinigen und zu formatieren.
Schritt 9: Testen Sie die Lag -Pipeline

Schlie?lich testen wir die Pipeline mit verschiedenen Benutzeranfragen. Für jede Abfrage ruft das System relevante Dokumentbrocken ab, führt sie durch das Sprachmodell und generiert eine Antwort.

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)

Das System iteriert jede Abfrage, ruft die Pipeline auf und druckt die generierte Antwort.

• für jede Abfrage verarbeitet das Modell den abgerufenen Kontext und liefert eine im Kontext begründete Antwort.
unten finden Sie Screenshots der Lagausgabe aus dem ursprünglichen Code. Sensible Informationen wurden maskiert, um die Integrit?t aufrechtzuerhalten.

Durch Kombination von Web-Scraping, Datenextraktion und RA-Techniken (Advanced Abruf-Augmented Generation) haben wir einen leistungsstarken und skalierbaren Rahmen für Unternehmensintelligenz geschaffen. Der erste Schritt beim Extrahieren von Links und das Abkratzen von Daten stellt sicher, dass wir relevante und aktuelle Informationen aus dem Web sammeln. Der zweite Abschnitt konzentriert sich darauf, bestimmte produktbezogene Details zu stecken, sodass die Daten effizient kategorisieren und verarbeitet werden.

Schlie?lich erm?glicht es uns, Lappen zu nutzen, indem wir dynamisch auf komplexe Abfragen reagieren, indem wir kontextbezogene Informationen aus riesigen Datens?tzen abrufen und synthetisieren. Zusammen bilden diese Komponenten ein umfassendes Setup, mit dem eine Agentenplattform erstellt werden kann, die in der Lage ist, Unternehmen zu sammeln, zu verarbeiten und zu liefern. Dieser Rahmen k?nnte als Grundlage für die Entwicklung fortschrittlicher Intelligenzsysteme dienen und es Unternehmen erm?glichen, Wettbewerbsanalysen zu automatisieren, Markttrends zu überwachen und über ihre Branche informiert zu bleiben.

Bereitstellung und Skalierung

Sobald das Unternehmensinformationssystem erstellt wurde, besteht der n?chste Schritt darin, es für die Produktionsnutzung bereitzustellen und zu skalieren. Sie k?nnen das System auf Cloud-Plattformen wie AWS oder GCP für Flexibilit?t und Skalierbarkeit bereitstellen oder sich für eine lokale L?sung entscheiden, wenn Datenschutzpriorit?t Priorit?t hat. Um das System benutzerfreundlicher zu gestalten, erstellen Sie eine einfache API oder Benutzeroberfl?che, mit der Benutzer mit der Plattform interagieren und mühelos Einblicke abrufen k?nnen. Wenn das System mit dem Umgang mit gr??eren Datens?tzen und h?heren Abfragenlasten beginnt, ist es wichtig, effizient zu skalieren.

Dies kann erreicht werden, indem verteilte Vektorspeicher genutzt und der Abrufprozess optimiert werden, um sicherzustellen, dass die Pipeline auch unter starkem Gebrauch reaktionsschnell und schnell bleibt. Mit den richtigen Infrastruktur- und Optimierungstechniken kann die Agentenplattform wachsen, um gro? an

Schlussfolgerung

In der heutigen datengesteuerten Welt ist es entscheidend, umsetzbare Erkenntnisse aus unstrukturierten Unternehmensdaten zu extrahieren. Ein RAG-System (Abruf-Augmented Generation) kombiniert Datenkratzen, Zeigerextraktion und intelligente Abfragen, um eine leistungsstarke Plattform für Unternehmensintelligenz zu schaffen. Durch das Organisieren von wichtigsten Informationen und das Aktivieren von Echtzeit, kontextspezifischen Antworten erm?glichen Rag-Systeme intelligente Entscheidungen in Organisationen und helfen Unternehmen, datenbützte, anpassbare Entscheidungen zu treffen.

Diese skalierbare L?sung w?chst mit Ihren Bedürfnissen, den Umgang mit komplexen Abfragen und gr??eren Datens?tzen und gleichzeitig die Genauigkeit. Mit der richtigen Infrastruktur wird diese KI-gesteuerte Plattform zu einem Eckpfeiler für intelligentere Operationen und erm?glicht es Unternehmen, ihre Daten zu nutzen, wettbewerbsf?hig zu bleiben und die Innovation durch intelligente Entscheidungen in Organisationen voranzutreiben.

Key Takeaways

• Linkextraktion und Web -Scraping verbessern die Unternehmensintelligenz durch die automatische, effiziente Datenerfassung aus mehreren Quellen mit minimalem Aufwand.
• Extrahieren von Schlüsselpunkten Extrahieren von unstrukturierten Inhalten in organisiertes, umsetzbares Wissen und St?rkung der Intelligenz von Unternehmen für KI-gesteuerte Erkenntnisse.
• Kombinieren Sie Rag mit einem benutzerdefinierten Vektorspeicher und optimiertes Retriever erm?glicht intelligente, kontextbewusste Antworten für eine bessere Entscheidungsfindung.
• Cloud-basierte L?sungen und verteilte Vektorspeicher gew?hrleisten eine effiziente Skalierung, bearbeiten gr??ere Datens?tze und Abfragen von Lasten ohne Leistungsverlust.
• Die Rag-Pipeline verarbeitet Echtzeitabfragen und liefert genaue On-Demand-Erkenntnisse direkt aus der Wissensbasis.

Bonus: Alle hier diskutierten Codes werden im folgenden Link verfügbar gemacht. Insgesamt sind 4 Notizbücher verfügbar, mit selbsterkl?renden Namen für jedes Notebook. Fühlen Sie sich frei, Unternehmen zu erkunden, zu entwickeln und zu revolutionieren!

h?ufig gestellte Fragen

q 1.?Was ist der Zweck der Verwendung von Retrieval-Augmented-Generation (LAG) in diesem Setup?

a. RAG verbessert die F?higkeit von KI-Modellen, kontextbezogene Antworten zu liefern, indem das Abrufen des Informationen mit generativer KI kombiniert wird. Es erm?glicht eine intelligentere Abfrage gro?er Datens?tze und erleichtert es, pr?zise, ??relevante Antworten zu relevanten, anstatt nur eine grundlegende Keyword -Suche durchzuführen.

q 2.?Welche Tools und Bibliotheken müssen das im Blog beschriebene System erstellen?

a. Zu den verwendeten prim?ren Tools und Bibliotheken geh?ren Python, BeautifulSoup für Web -Scraping, Langchain für die Verwaltung von Dokumentenabruf, OpenAI -Modelle für die Verarbeitung natürlicher Sprache und Chroma zum Speichern vektorisierter Dokumente. Diese Komponenten arbeiten zusammen, um eine umfassende Plattform für Unternehmensinformationen zu erstellen.

q 3.?Wie funktioniert der Zeigerextraktionsprozess in diesem System?

a. Die Zeigerextraktion umfasst die Identifizierung spezifischer Informationen aus dem abgekratzten Inhalt wie Produktfunktionen, Integrationen und Fehlerbehebungstipps. Die Daten werden unter Verwendung eines prompt gesteuerten Systems verarbeitet, das die Informationen in strukturierten, umsetzbaren Erkenntnissen organisiert. Dies wird unter Verwendung einer Kombination aus KI -Modellen und benutzerdefinierten Eingabeaufforderungen erreicht.

q 4.?Wie verbessern Rag- und AI -Agenten die Intelligenz des Unternehmens?

a. RAG- und AI-Agenten verbessern Unternehmensintelligenz Durch automatisierende Datenabnahme, Verarbeitung und Analyse und erm?glichten Unternehmen, Echtzeit, umsetzbare Erkenntnisse zu extrahieren.

Q5. Warum ist das Schaber von Daten für Unternehmensintelligenz wichtig?

a. Datenkratzer hilft dabei, ein starkes Unternehmensintelligenz-System zu erstellen, indem wertvolle Informationen aus mehreren Quellen für fundierte Entscheidungen gesammelt und strukturiert werden.

Die in diesem Artikel gezeigten Medien sind nicht im Besitz von Analytics Vidhya und wird nach Ermessen des Autors verwendet.

Das obige ist der detaillierte Inhalt vonAufbau eines Lappensystems für intelligente Entscheidungen in Organisationen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!