Membina sistem kain rag untuk membuat keputusan pintar dalam organisasi

Dalam persekitaran perniagaan yang pantas hari ini, organisasi dibanjiri dengan data yang mendorong keputusan, mengoptimumkan operasi, dan mengekalkan daya saing. Walau bagaimanapun, mengekstrak pandangan yang boleh diambil tindakan dari data ini kekal sebagai halangan penting. Sistem generasi pengambilan semula (RAG), apabila diintegrasikan dengan AIS AIS, menangani cabaran ini dengan tidak hanya mendapatkan maklumat yang relevan tetapi juga memproses dan menyampaikan pandangan konteks yang menyedari konteks dalam masa nyata. Gabungan ini membolehkan perniagaan membuat ejen pintar yang secara autonomi menanyakan dataset, menyesuaikan, dan mengekstrak pandangan mengenai ciri produk, integrasi, dan operasi.

Dengan menggabungkan RAG dengan agentik AI, perniagaan dapat meningkatkan membuat keputusan dan menukar data yang bertaburan ke dalam kecerdasan yang berharga. Blog ini meneroka proses membina saluran paip RAG dengan AIS AI, menawarkan pandangan teknikal dan contoh kod untuk memperkasakan pengambilan keputusan pintar dalam organisasi.

Objektif Pembelajaran

• Ketahui cara mengekstrak dan mengikis data yang relevan secara automatik dari pelbagai sumber web menggunakan alat Python dan mengikis, membentuk asas bagi mana -mana platform perisikan syarikat.
Ketahui cara menyusun dan memproses data yang dikikis ke dalam pandangan yang berharga dan boleh dilakukan dengan mengekstrak mata utama seperti fungsi produk, integrasi, dan langkah penyelesaian masalah menggunakan teknik yang didorong oleh AI.
• Ketahui cara mengintegrasikan RAG dengan pengambilan semula dokumen dan generasi bahasa semulajadi untuk membina sistem pertanyaan pintar yang mampu menyampaikan jawapan yang menyedari konteks dari dataset yang luas.
Memahami cara membina sistem AI yang agentik yang menggabungkan pengikatan data, pengekstrakan pengetahuan, dan pemprosesan pertanyaan masa nyata, membolehkan perniagaan mengekstrak pandangan yang boleh dilakukan secara autonomi.
• Dapatkan pemahaman bagaimana untuk skala dan menggunakan sistem sedemikian menggunakan platform awan dan arsitektur yang diedarkan, memastikan ia dapat mengendalikan dataset yang besar dan beban pertanyaan yang tinggi dengan berkesan.
• Artikel ini diterbitkan sebagai sebahagian daripada Blogathon Sains Data

Jadual Kandungan

Pengekstrakan data menggunakan BFS dan mengikis data
pengekstrakan maklumat yang mengaut
• Pengekstrakan data menggunakan BFS dan mengikis data
• Langkah pertama dalam membina sistem RAG yang mantap untuk kecerdasan syarikat adalah mengumpul data yang diperlukan. Oleh kerana data boleh datang dari pelbagai sumber web, mengikis dan menganjurkannya dengan cekap adalah kunci. Satu teknik yang berkesan untuk menemui dan mengumpul halaman yang berkaitan adalah carian lebar pertama (BFS). BFS membantu kami menemui pautan secara rekursif bermula dari halaman utama, secara beransur -ansur mengembangkan carian ke tahap yang lebih mendalam. Ini memastikan bahawa kami mengumpulkan semua halaman yang relevan tanpa mengatasi sistem dengan data yang tidak perlu.
• Dalam bahagian ini, kita akan melihat cara mengekstrak pautan dari laman web menggunakan BFS, diikuti dengan mengikis kandungan dari halaman tersebut. Menggunakan BFS, kami secara sistematik melintasi laman web, mengumpul data, dan membuat dataset yang bermakna untuk diproses dalam saluran paip RAG.
• Langkah 1: Pengekstrakan pautan menggunakan BFS

Untuk memulakan, kita perlu mengumpul semua pautan yang berkaitan dari laman web yang diberikan. Menggunakan BFS, kita boleh meneroka pautan di laman utama, dan dari sana, ikut pautan di halaman lain secara rekursif sehingga kedalaman yang ditentukan. Kaedah ini memastikan bahawa kami menangkap semua halaman yang diperlukan yang mungkin mengandungi data syarikat yang berkaitan, seperti ciri produk, integrasi, atau butiran utama lain.

Kod di bawah melakukan pengekstrakan pautan dari URL permulaan menggunakan BFS. Ia bermula dengan mengambil halaman utama, mengekstrak semua pautan (& lt; a & gt; tag dengan atribut HREF), dan kemudian mengikuti pautan ini ke halaman berikutnya, secara rekursif mengembangkan carian berdasarkan had kedalaman yang diberikan.

inilah kod untuk melakukan pengekstrakan pautan:

kami mengekalkan barisan untuk mengesan URL untuk melawat bersama dengan kedalaman yang sama, memastikan traversal yang cekap. Set yang dikunjungi digunakan untuk mengelakkan menyemak semula URL yang sama beberapa kali. Untuk setiap URL, kami menggunakan BeautifulSoup untuk menghuraikan HTML dan mengekstrak semua pautan (tag dengan atribut HREF). Proses ini menggunakan BFS traversal, mengambil rekursif setiap kandungan URL, mengekstrak pautan, dan meneroka lagi sehingga mencapai had kedalaman. Pendekatan ini memastikan kami meneroka web dengan cekap tanpa redundansi.

output

Kod ini mengeluarkan senarai pautan yang diekstrak dari laman web, sehingga kedalaman yang ditentukan.

output menunjukkan bahawa sistem yang dijumpai dan dikumpulkan 1500 pautan dari laman web permulaan dan halaman yang dikaitkan sehingga kedalaman 3. Anda akan menggantikan https://www.example.com dengan URL sasaran sebenar anda. Berikut adalah tangkapan skrin output kod asal. Maklumat sensitif telah bertopeng untuk mengekalkan integriti.

Langkah 2: Mengikis data dari pautan yang diekstrak

Sebaik sahaja kami telah mengekstrak pautan yang berkaitan dengan menggunakan BFS, langkah seterusnya adalah untuk mengikis kandungan dari halaman ini. Kami akan mencari maklumat penting seperti ciri produk, integrasi, dan data lain yang berkaitan yang akan membantu kami membina dataset berstruktur untuk sistem RAG.

Dalam langkah ini, kami gelung melalui senarai pautan yang diekstrak dan mengikis kandungan utama, seperti tajuk halaman dan kandungan utamanya. Anda boleh menyesuaikan kod ini untuk mengikis titik data tambahan seperti yang diperlukan (mis., Ciri produk, harga, atau maklumat 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.")

Untuk setiap URL dalam senarai, kami menghantar permintaan HTTP untuk mengambil kandungan halaman dan menghuraikannya menggunakan BeautifulSoup untuk mengekstrak tajuk dan kandungan utama. Kami menyimpan data yang diekstrak dalam senarai kamus, masing -masing mengandungi URL, tajuk, dan kandungan. Akhirnya, kami menyimpan data yang dikikis ke dalam fail JSON, memastikan ia tersedia untuk pemprosesan kemudian dalam saluran paip RAG. Proses ini memastikan pengumpulan dan penyimpanan data yang relevan untuk kegunaan selanjutnya.

output

Output kod ini akan menjadi fail JSON yang disimpan (scraped_data.json) yang mengandungi data yang dikikis dari pautan. Contoh struktur data boleh kelihatan seperti ini:

Extracted 1500 links.

Fail JSON ini mengandungi URL, tajuk, dan kandungan untuk setiap halaman yang kami dikikis. Data berstruktur ini kini boleh digunakan untuk pemprosesan selanjutnya, seperti penyembuhan generasi dan soal jawab dalam sistem RAG. Berikut adalah tangkapan skrin output kod asal. Maklumat sensitif telah bertopeng untuk mengekalkan integriti.

mengautomasikan pengekstrakan maklumat dengan ejen AI

Di bahagian sebelumnya, kami meliputi proses mengikis pautan dan mengumpul kandungan web mentah menggunakan strategi carian lebar pertama (BFS). Sebaik sahaja data yang diperlukan dikikis, kami memerlukan sistem yang mantap untuk menganjurkan dan mengekstrak pandangan yang boleh ditindaklanjuti dari kandungan mentah ini. Di sinilah langkah -langkah Agentic AI dalam: Dengan memproses data yang dikikis, ia secara automatik membentuk maklumat ke dalam bahagian yang bermakna.

Dalam seksyen ini, kami memberi tumpuan kepada bagaimana Agentic AI mengekstrak maklumat produk yang relevan dari data yang dikikis, memastikan ia bersedia untuk penggunaan pihak berkepentingan. Kami akan memecahkan langkah -langkah utama yang terlibat, dari memuatkan data untuk memprosesnya dan akhirnya menyimpan hasil dalam format berstruktur.

Langkah 1: Memuatkan data yang dikikis

Langkah pertama dalam proses ini adalah untuk memuatkan kandungan dikikis mentah ke dalam sistem kami. Seperti yang kita lihat sebelum ini, data yang dikikis disimpan dalam format JSON, dan setiap entri termasuk URL dan kandungan yang berkaitan. Kita perlu memastikan bahawa data ini berada dalam format yang sesuai untuk diproses AI.

coretan kod:

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

Di sini, kami memuatkan keseluruhan dataset ke dalam memori menggunakan perpustakaan JSON terbina dalam Python. Setiap entri dalam dataset mengandungi URL sumber dan medan text_content, yang memegang teks dikikis mentah. Kandungan ini adalah apa yang akan kita proses dalam langkah seterusnya.

Langkah 2: Mengekstrak Kandungan Teks Mentah

Seterusnya, kami melangkah melalui dataset untuk mengekstrak text_content yang berkaitan untuk setiap entri. Ini memastikan bahawa kami hanya bekerja dengan entri yang sah yang mengandungi kandungan yang diperlukan. Penyertaan yang tidak sah atau tidak lengkap dilangkau untuk mengekalkan integriti proses.

coretan kod:

Extracted 1500 links.

Pada ketika ini, pembolehubah input_text mengandungi kandungan teks mentah yang akan kami hantar ke model AI untuk pemprosesan selanjutnya. Adalah penting bahawa kami memastikan kehadiran kunci yang diperlukan sebelum memproses setiap entri.

Langkah 3: Menghantar data ke ejen AI untuk pemprosesan

Selepas mengekstrak kandungan mentah, kami menghantarnya ke model AI AIS untuk pengekstrakan berstruktur. Kami berinteraksi dengan API Groq untuk meminta pandangan berstruktur berdasarkan arahan yang telah ditetapkan. Model AI memproses kandungan dan mengembalikan maklumat teratur yang meliputi aspek utama seperti keupayaan produk, integrasi, dan langkah penyelesaian masalah.

coretan kod:

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

di sini, kod ini memulakan panggilan API ke Groq, menghantar input_text dan arahan sebagai sebahagian daripada muatan mesej. Mesej sistem mengarahkan model AI pada tugas yang tepat untuk dilakukan, sementara mesej pengguna menyediakan kandungan yang akan diproses. Kami menggunakan parameter suhu, max_tokens, dan top_p untuk mengawal rawak dan panjang output yang dihasilkan.

Konfigurasi panggilan API:

• Model: Menentukan model yang akan digunakan. Dalam kes ini, model bahasa dipilih untuk memastikan ia dapat mengendalikan data teks dan menghasilkan respons.
• suhu: mengawal kreativiti respons. Nilai yang lebih tinggi membawa kepada tindak balas yang lebih kreatif, manakala nilai yang lebih rendah menjadikannya lebih deterministik.
• max_tokens: Menetapkan panjang maksimum respons yang dihasilkan.
• top_p: Menentukan taburan kebarangkalian kumulatif untuk pemilihan token, mengawal kepelbagaian dalam tindak balas.
Langkah 4: Pemprosesan dan Mengumpul Hasil

Setelah model AI memproses kandungan, ia mengembalikan potongan maklumat berstruktur. Kami mengumpul dan menggabungkan ketulan ini untuk membuat satu set hasil penuh, memastikan tiada data hilang dan output akhir selesai.

coretan kod:

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

Coretan Kod ini menggabungkan kandungan dari setiap bahagian ke pm_points pembolehubah, menghasilkan satu set wawasan yang penuh dan berstruktur. Ia mengekstrak pandangan ini dalam format yang pihak berkepentingan dengan mudah boleh menggunakan atau menggunakan untuk analisis selanjutnya. Berikut adalah tangkapan skrin output kod asal, dengan maklumat sensitif bertopeng untuk mengekalkan integriti.

Langkah 5: Pengendalian ralat dan mengekalkan integriti data

Semasa memproses, selalu ada kemungkinan menghadapi kesilapan, seperti kandungan atau isu rangkaian yang tidak lengkap. Dengan menggunakan mekanisme pengendalian ralat, kami memastikan bahawa proses terus lancar untuk semua entri yang sah.

coretan kod:

Extracted 1500 links.

Blok Cuba-Except ini menangkap dan log sebarang kesilapan, memastikan sistem terus memproses entri lain. Sekiranya entri tertentu menyebabkan masalah, sistem menandakannya untuk semakan tanpa menghentikan proses keseluruhan.

Langkah 6: Menyimpan data yang diproses

Selepas AI memproses kandungan dan mengembalikan pandangan berstruktur, langkah terakhir menyimpan data ini untuk kegunaan kemudian. Kami menulis hasil berstruktur kembali ke fail JSON, memastikan bahawa setiap entri mempunyai maklumat yang diproses sendiri yang disimpan untuk analisis selanjutnya.

coretan kod:

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

Kod ini menyimpan data yang diproses dengan cekap dan membolehkan akses mudah kemudian. Ia menjimatkan setiap entri dengan titik berstruktur masing -masing, membuat pengambilan dan analisis maklumat yang diekstrak dengan mudah. ​​

output

Selepas menjalankan kod di atas, fail JSON yang diproses akan mengandungi titik yang diekstrak untuk setiap entri. Bidang PM_Points akan memegang maklumat berstruktur yang berkaitan dengan keupayaan produk, integrasi, langkah penyelesaian masalah, dan banyak lagi, bersedia untuk analisis atau integrasi selanjutnya ke dalam aliran kerja anda.

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

di bawah adalah tangkapan skrin output kod asal. Maklumat sensitif telah bertopeng untuk mengekalkan integriti.

pelaksanaan saluran paip generasi pengambilan semula

Di bahagian sebelumnya, kami memberi tumpuan kepada pengekstrakan data dari laman web dan menukarnya ke dalam format berstruktur seperti JSON. Kami juga melaksanakan teknik untuk mengekstrak dan membersihkan data yang relevan, yang membolehkan kami menghasilkan dataset yang siap untuk analisis yang lebih mendalam.

Membangun pada bahagian ini, kami akan melaksanakan saluran paip generasi pengambilan semula (RAG), yang menggabungkan penjanaan model pengambilan dan bahasa untuk menjawab soalan berdasarkan maklumat yang diekstrak.

Dengan mengintegrasikan data berstruktur yang kami telah dikikis dan diproses sebelum ini, saluran paip RAG ini bukan sahaja akan mengambil potongan dokumen yang paling relevan tetapi juga menghasilkan respons yang tepat dan berwawasan berdasarkan konteks itu.

Langkah 1: Menyediakan Alam Sekitar

Untuk memulakan, mari kita pasang semua kebergantungan yang diperlukan untuk saluran paip RAG:

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

Pakej -pakej ini penting untuk mengintegrasikan pemprosesan dokumen, vektorisasi, dan model terbuka dalam Langchain. JQ adalah pemproses JSON yang ringan, sementara Langchain berfungsi sebagai kerangka teras untuk membina saluran paip model bahasa. Langchain-Openai memudahkan integrasi model terbuka seperti GPT, dan Langchain-Chroma menawarkan kedai vektor berasaskan Chroma untuk menguruskan embeddings dokumen.

Selain itu, kami menggunakan transformer kalimat untuk menjana embedding teks dengan model pengubah pra-terlatih, membolehkan pengendalian dan pengambilan dokumen yang cekap.

Langkah 2: Memuatkan data yang diekstrak

Sekarang, kami akan memuatkan data berstruktur yang telah diekstrak dan diproses di bahagian sebelumnya menggunakan jsonLoader. Data ini, misalnya, boleh dikikis dari laman web sebagai JSON berstruktur, dengan pasangan nilai utama yang berkaitan dengan topik atau soalan tertentu.

Extracted 1500 links.

Dalam langkah ini, data yang sebelum ini diekstrak (mungkin mengandungi keupayaan produk, integrasi, dan ciri) dimuatkan untuk pemprosesan selanjutnya.

Langkah 3: Memisahkan dokumen ke dalam ketulan yang lebih kecil

Sekarang kita mempunyai data mentah, kita menggunakan recursiveCharactertextsplitter untuk memecahkan dokumen ke dalam ketulan yang lebih kecil. Ini memastikan bahawa tiada bahagian tunggal melebihi had token model bahasa.

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

RecursiveCharactertextsplitter membahagikan dokumen ke dalam segmen yang lebih kecil, memastikan pertindihan yang dipelihara dipelihara untuk pemahaman kontekstual yang lebih baik. Parameter chunk_size menentukan saiz setiap bahagian, manakala chunk_overlap memastikan maklumat penting dikekalkan di bahagian -bahagian bersebelahan. Di samping itu, add_start_index membantu mengekalkan pesanan dokumen dengan memasukkan indeks, yang membolehkan pengesanan mudah di mana setiap bahagian berasal dari dokumen asal.

Langkah 4: Menjana Embeddings untuk Dokumen Dokumen

Sekarang, kita menukar setiap bahagian teks ke dalam embeddings menggunakan sentenceTransformer. Lembaran ini mewakili makna teks dalam ruang vektor dimensi tinggi, yang berguna untuk mencari dan mengambil dokumen yang relevan kemudian.

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

SentenceTransformer digunakan untuk menghasilkan embeddings untuk ketulan teks, mewujudkan perwakilan vektor padat yang menangkap maklumat semantik. Fungsi embed_documents memproses pelbagai dokumen dan mengembalikan embeddings mereka, sementara Embed_Query menghasilkan embeddings untuk pertanyaan pengguna. Chroma, kedai vektor, menguruskan embeddings ini dan membolehkan pengambilan semula yang cekap berdasarkan persamaan, yang membolehkan dokumen cepat dan tepat atau pemadanan pertanyaan.

Langkah 5: Menyediakan Retriever

Sekarang kita mengkonfigurasi retriever. Komponen ini mencari potongan teks yang paling relevan berdasarkan pertanyaan pengguna. Ia mengambil bahagian-bahagian dokumen yang paling serupa dengan pertanyaan.

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

• Retriever menggunakan carian persamaan untuk mencari ketulan yang paling relevan dari kedai vektor.
• Parameter k = 6 bermaksud ia akan mengembalikan 6 ketulan teratas yang paling relevan dengan pertanyaan.

Langkah 6: Mewujudkan Templat Prompt

Seterusnya, kami membuat templat segera yang akan memformat input untuk model bahasa. Templat ini merangkumi kedua -dua konteks (potongan yang diambil) dan pertanyaan pengguna, membimbing model untuk menghasilkan jawapan berdasarkan hanya pada konteks yang disediakan.

Extracted 1500 links.

• Format ChatPromptTemplate Input untuk model dengan cara yang menekankan keperluan untuk jawapannya semata -mata berdasarkan konteks yang diberikan.
• {context} akan digantikan dengan ketulan teks yang relevan, dan {soalan} akan digantikan dengan pertanyaan pengguna.

Langkah 7: Menyediakan Model Bahasa

Dalam langkah ini, kami memulakan model OpenAI GPT. Model ini akan menghasilkan jawapan berdasarkan konteks berstruktur yang disediakan oleh 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.")

• kami memulakan model Chatopenai, yang akan memproses segera dan menghasilkan jawapan.
• Kami menggunakan model yang lebih kecil, "GPT-4O-Mini", untuk pemprosesan yang cekap, walaupun model yang lebih besar boleh digunakan untuk tugas yang lebih kompleks.

Langkah 8: Membina saluran paip RAG

di sini, kami mengintegrasikan semua komponen (retriever, prompt, llm) ke dalam saluran paip kain kohesif. Paip ini akan mengambil pertanyaan, mengambil konteks yang relevan, melewati model, dan menghasilkan respons.

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

• runnablePassthrough memastikan bahawa pertanyaan diluluskan terus ke prompt.
• stroutputparser digunakan untuk membersihkan dan memformat output dari model ke dalam format rentetan.

Langkah 9: Menguji saluran paip RAG

Akhirnya, kami menguji saluran paip dengan pelbagai pertanyaan pengguna. Untuk setiap pertanyaan, sistem mengambil potongan dokumen yang relevan, melewati mereka melalui model bahasa, dan menghasilkan respons.

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)

• Sistem melangkah melalui setiap pertanyaan, memohon saluran paip dan mencetak jawapan yang dihasilkan.
• Untuk setiap pertanyaan, model memproses konteks yang diambil dan memberikan jawapan yang berasaskan dalam konteks.

di bawah adalah tangkapan skrin output RAG dari kod asal. Maklumat sensitif telah bertopeng untuk mengekalkan integriti.

Dengan menggabungkan pengikis web, pengekstrakan data, dan teknik generasi pengambilan semula (RAG), kami telah mencipta rangka kerja yang kuat dan berskala untuk kecerdasan syarikat. Langkah pertama mengekstrak pautan dan mengikis data memastikan kami mengumpulkan maklumat yang relevan dan terkini dari web. Bahagian kedua memberi tumpuan kepada menunjuk butiran berkaitan produk tertentu, menjadikannya lebih mudah untuk mengkategorikan dan memproses data dengan cekap.

Akhirnya, memanfaatkan RAG membolehkan kami memberi respons secara dinamik kepada pertanyaan yang kompleks dengan mengambil dan mensintesis maklumat kontekstual dari dataset yang luas. Bersama -sama, komponen -komponen ini membentuk persediaan yang komprehensif yang boleh digunakan untuk membina platform agentik yang mampu mengumpulkan, memproses, dan menyampaikan pandangan yang dapat ditindaklanjuti oleh syarikat. Rangka kerja ini boleh menjadi asas untuk membangunkan sistem kecerdasan maju, membolehkan organisasi mengautomasikan analisis kompetitif, memantau trend pasaran, dan terus dimaklumkan mengenai industri mereka.

penyebaran dan skala

Setelah sistem perisikan syarikat dibina, langkah seterusnya adalah untuk menggunakan dan skala untuk kegunaan pengeluaran. Anda boleh menggunakan sistem pada platform awan seperti AWS atau GCP untuk fleksibiliti dan skalabiliti, atau memilih penyelesaian di premis jika privasi data adalah keutamaan. Untuk menjadikan sistem lebih mesra pengguna, pertimbangkan untuk membina API atau UI yang mudah yang membolehkan pengguna berinteraksi dengan platform dan mengambil pandangan dengan mudah. Oleh kerana sistem mula mengendalikan dataset yang lebih besar dan beban pertanyaan yang lebih tinggi, penting untuk skala dengan cekap.

Ini dapat dicapai dengan memanfaatkan kedai vektor yang diedarkan dan mengoptimumkan proses pengambilan semula, memastikan bahawa saluran paip tetap responsif dan cepat walaupun di bawah penggunaan berat. Dengan teknik infrastruktur dan pengoptimuman yang betul di tempat, platform Agentic dapat berkembang untuk menyokong operasi berskala besar, membolehkan pandangan masa nyata dan mengekalkan kelebihan daya saing dalam kecerdasan syarikat.

Kesimpulan

Di dunia yang didorong oleh data hari ini, mengekstrak pandangan yang boleh diambil tindakan dari data syarikat yang tidak berstruktur adalah penting. Sistem Generasi Pengambilan Rekrut (RAG) menggabungkan pengikatan data, pengekstrakan penunjuk, dan pertanyaan pintar untuk membuat platform yang kuat untuk kecerdasan syarikat. Dengan menganjurkan maklumat penting dan membolehkan tindak balas khusus konteks, sistem RAG memberi kuasa kepada pengambilan keputusan pintar dalam organisasi, membantu perniagaan membuat keputusan yang disokong, disesuaikan dengan data.

Penyelesaian berskala ini tumbuh dengan keperluan anda, mengendalikan pertanyaan kompleks dan dataset yang lebih besar sambil mengekalkan ketepatan. Dengan infrastruktur yang betul, platform yang didorong oleh AI ini menjadi asas bagi operasi yang lebih bijak, membolehkan organisasi memanfaatkan data mereka, kekal berdaya saing, dan memacu inovasi melalui pengambilan keputusan pintar dalam organisasi.

Takeaways Key

• pengekstrakan pautan dan pengikis web meningkatkan kecerdasan syarikat dengan membolehkan pengumpulan data automatik dan cekap dari pelbagai sumber dengan usaha yang minimum.
• Mengekstrak mata data utama mengubah kandungan yang tidak berstruktur ke dalam pengetahuan yang teratur, boleh diambil tindakan, mengukuhkan kecerdasan syarikat untuk pandangan AI-didorong.
• Menggabungkan kain dengan kedai vektor tersuai dan retriever yang dioptimumkan membolehkan respons yang bijak, konteks yang menyedari untuk membuat keputusan yang lebih baik.
• penyelesaian berasaskan awan dan kedai vektor yang diedarkan memastikan skala yang cekap, mengendalikan dataset yang lebih besar dan beban pertanyaan tanpa kehilangan prestasi.
• Proses Pipeline RAG Pertanyaan masa nyata, memberikan pandangan yang tepat, atas permintaan secara langsung dari pangkalan pengetahuan.

Bonus: Semua kod yang dibincangkan di sini disediakan dalam pautan berikut. Sebanyak 4 buku nota boleh didapati, dengan nama-nama jelas untuk setiap buku nota. Jangan ragu untuk meneroka, membangun dan merevolusikan perusahaan!

Soalan Lazim

q 1. Apakah tujuan menggunakan generasi pengambilan semula (RAG) dalam persediaan ini? a. RAG meningkatkan keupayaan model AI untuk memberikan respons yang menyedari konteks dengan menggabungkan pengambilan maklumat dengan AI generatif. Ia membolehkan pertanyaan yang lebih bijak dari dataset yang besar, menjadikannya lebih mudah untuk mendapatkan jawapan yang tepat dan relevan daripada hanya melakukan carian kata kunci asas. Alat dan perpustakaan apa yang diperlukan untuk membina sistem yang diterangkan dalam blog?

a. Alat dan perpustakaan utama yang digunakan termasuk Python, BeautifulSoup untuk mengikis web, Langkhain untuk menguruskan pengambilan dokumen, model OpenAI untuk pemprosesan bahasa semulajadi, dan Chroma untuk menyimpan dokumen vektor. Komponen ini bekerjasama untuk mewujudkan platform perisikan syarikat yang komprehensif. q 3. Bagaimanakah proses pengekstrakan penunjuk berfungsi dalam sistem ini? a. Pengekstrakan penunjuk melibatkan mengenal pasti maklumat khusus dari kandungan yang dikikis, seperti ciri produk, integrasi, dan tip penyelesaian masalah. Data diproses dengan menggunakan sistem yang didorong oleh cepat, yang menganjurkan maklumat ke dalam pandangan berstruktur dan boleh diambil tindakan. Ini dicapai dengan menggunakan gabungan model AI dan petikan adat. Bagaimanakah ejen RAG dan AI meningkatkan kecerdasan syarikat?

a. Ejen RAG dan AI meningkatkan kecerdasan syarikat dengan mengautomasikan pengambilan, pemprosesan, dan analisis data, membolehkan perniagaan mengekstrak pandangan masa nyata, yang boleh diambil tindakan. Kenapa data mengikis penting untuk kecerdasan syarikat? a. Pengikis data membantu membina sistem Intelligence syarikat yang kuat dengan mengumpul dan menstrukturkan maklumat berharga dari pelbagai sumber untuk membuat keputusan yang dimaklumkan.

Media yang ditunjukkan dalam artikel ini tidak dimiliki oleh Analytics Vidhya dan digunakan pada budi bicara penulis.

Atas ialah kandungan terperinci Membina sistem kain rag untuk membuat keputusan pintar dalam organisasi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!