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.
Dieser Artikel wurde als Teil des Data Science -Blogathon veröffentlicht.
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.
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.
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.
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.
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.
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.
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.
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.
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:
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.")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.
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.")
[
{
"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."
}
]
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)
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.
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.
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!
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!
Was ist ein Servomotor?
Einführung in SEO-Diagnosemethoden
Was beinhaltet die Datenverschlüsselungsspeicherung?
Was sind die Hauptunterschiede zwischen Linux und Windows?
Ein Speicher, der Informationen direkt mit der CPU austauschen kann, ist ein
So öffnen Sie eine MDS-Datei
Ändern Sie die Hintergrundfarbe des Wortes in Weiß
Welche Entwicklungstools gibt es?
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
