Chatten Sie mit Ihrem PDF mit Pinata, OpenAI und Streamlit

In diesem Tutorial erstellen wir eine einfache Chat-Schnittstelle, die es Benutzern ermöglicht, eine PDF-Datei hochzuladen, deren Inhalt mithilfe der OpenAI-API abzurufen und die Antworten mithilfe von in einer Chat-ähnlichen Oberfläche anzuzeigen Streamlit. Wir werden auch @pinata nutzen, um die PDF-Dateien hochzuladen und zu speichern.

Lassen Sie uns einen kleinen Blick auf das werfen, was wir gerade aufbauen, bevor wir fortfahren:

Voraussetzungen:

• Grundkenntnisse in Python
• Pinata-API-Schlüssel (zum Hochladen von PDFs)
• OpenAI-API-Schlüssel (zum Generieren von Antworten)
• Streamlit installiert (zum Erstellen der Benutzeroberfläche)

Schritt 1: Projekteinrichtung

Erstellen Sie zunächst ein neues Python-Projektverzeichnis:

mkdir chat-with-pdf
cd chat-with-pdf
python3 -m venv venv
source venv/bin/activate
pip install streamlit openai requests PyPDF2

Erstellen Sie nun eine .env-Datei im Stammverzeichnis Ihres Projekts und fügen Sie die folgenden Umgebungsvariablen hinzu:

PINATA_API_KEY=<Your Pinata API Key>
PINATA_SECRET_API_KEY=<Your Pinata Secret Key>
OPENAI_API_KEY=<Your OpenAI API Key>

Man muss OPENAI_API_KEY selbst verwalten, da es kostenpflichtig ist. Aber lassen Sie uns den Prozess der Erstellung von API-Schlüsseln in Pinita durchgehen.

Also, bevor wir fortfahren, lassen Sie uns wissen, was Pinata ist, warum wir es verwenden.

Pinata ist ein Dienst, der eine Plattform zum Speichern und Verwalten von Dateien auf IPFS (InterPlanetary File System) bereitstellt, einem dezentralen und verteilten Dateispeichersystem.

• Dezentrale Speicherung: Pinata hilft Ihnen beim Speichern von Dateien auf IPFS, einem dezentralen Netzwerk.
• Einfach zu bedienen: Es bietet benutzerfreundliche Tools und APIs für die Dateiverwaltung.
• Dateiverfügbarkeit: Pinata hält Ihre Dateien zugänglich, indem es sie auf IPFS „anheftet“.
• NFT-Unterstützung:Es eignet sich hervorragend zum Speichern von Metadaten für NFTs und Web3-Apps.
• Kostengünstig: Pinata kann eine günstigere Alternative zum herkömmlichen Cloud-Speicher sein.

Lassen Sie uns die erforderlichen Token erstellen, indem Sie sich anmelden:

Der nächste Schritt besteht darin, Ihre registrierte E-Mail-Adresse zu bestätigen:

Nach der Überprüfung der Anmeldung zum Generieren von API-Schlüsseln:

Danach gehen Sie zum Abschnitt „API-Schlüssel“ und erstellen Sie neue API-Schlüssel:

Schließlich wurden die Schlüssel erfolgreich generiert. Bitte kopieren Sie diese Schlüssel und speichern Sie sie in Ihrem Code-Editor.

OPENAI_API_KEY=<Your OpenAI API Key>
PINATA_API_KEY=dfc05775d0c8a1743247
PINATA_SECRET_API_KEY=a54a70cd227a85e68615a5682500d73e9a12cd211dfbf5e25179830dc8278efc

Schritt 2: PDF-Upload mit Pinata

Wir verwenden die API von Pinata, um PDFs hochzuladen und einen Hash (CID) für jede Datei zu erhalten. Erstellen Sie eine Datei mit dem Namen pinata_helper.py, um den PDF-Upload zu verarbeiten.

import os  # Import the os module to interact with the operating system
import requests  # Import the requests library to make HTTP requests
from dotenv import load_dotenv  # Import load_dotenv to load environment variables from a .env file

# Load environment variables from the .env file
load_dotenv()

# Define the Pinata API URL for pinning files to IPFS
PINATA_API_URL = "https://api.pinata.cloud/pinning/pinFileToIPFS"

# Retrieve Pinata API keys from environment variables
PINATA_API_KEY = os.getenv("PINATA_API_KEY")
PINATA_SECRET_API_KEY = os.getenv("PINATA_SECRET_API_KEY")

def upload_pdf_to_pinata(file_path):
    """
    Uploads a PDF file to Pinata's IPFS service.

    Args:
        file_path (str): The path to the PDF file to be uploaded.

    Returns:
        str: The IPFS hash of the uploaded file if successful, None otherwise.
    """
    # Prepare headers for the API request with the Pinata API keys
    headers = {
        "pinata_api_key": PINATA_API_KEY,
        "pinata_secret_api_key": PINATA_SECRET_API_KEY
    }

    # Open the file in binary read mode
    with open(file_path, 'rb') as file:
        # Send a POST request to Pinata API to upload the file
        response = requests.post(PINATA_API_URL, files={'file': file}, headers=headers)

        # Check if the request was successful (status code 200)
        if response.status_code == 200:
            print("File uploaded successfully")  # Print success message
            # Return the IPFS hash from the response JSON
            return response.json()['IpfsHash']
        else:
            # Print an error message if the upload failed
            print(f"Error: {response.text}")
            return None  # Return None to indicate failure

Schritt 3: OpenAI einrichten
Als Nächstes erstellen wir eine Funktion, die die OpenAI-API verwendet, um mit dem aus der PDF-Datei extrahierten Text zu interagieren. Wir nutzen das gpt-4o- oder gpt-4o-mini-Modell von OpenAI für Chat-Antworten.

Erstellen Sie eine neue Datei openai_helper.py:

import os
from openai import OpenAI
from dotenv import load_dotenv

# Load environment variables from .env file
load_dotenv()

# Initialize OpenAI client with the API key
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
client = OpenAI(api_key=OPENAI_API_KEY)

def get_openai_response(text, pdf_text):
    try:
        # Create the chat completion request
        print("User Input:", text)
        print("PDF Content:", pdf_text)  # Optional: for debugging

        # Combine the user's input and PDF content for context
        messages = [
            {"role": "system", "content": "You are a helpful assistant for answering questions about the PDF."},
            {"role": "user", "content": pdf_text},  # Providing the PDF content
            {"role": "user", "content": text}  # Providing the user question or request
        ]

        response = client.chat.completions.create(
            model="gpt-4",  # Use "gpt-4" or "gpt-4o mini" based on your access
            messages=messages,
            max_tokens=100,  # Adjust as necessary
            temperature=0.7  # Adjust to control response creativity
        )

        # Extract the content of the response
        return response.choices[0].message.content  # Corrected access method
    except Exception as e:
        return f"Error: {str(e)}"

Schritt 4: Erstellen der Streamlit-Schnittstelle

Da wir nun unsere Hilfsfunktionen bereit haben, ist es an der Zeit, die Streamlit-App zu erstellen, die PDFs hochlädt, Antworten von OpenAI abruft und den Chat anzeigt.

Erstellen Sie eine Datei mit dem Namen app.py:

import streamlit as st
import os
import time
from pinata_helper import upload_pdf_to_pinata
from openai_helper import get_openai_response
from PyPDF2 import PdfReader
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

st.set_page_config(page_title="Chat with PDFs", layout="centered")

st.title("Chat with PDFs using OpenAI and Pinata")

uploaded_file = st.file_uploader("Upload your PDF", type="pdf")

# Initialize session state for chat history and loading state
if "chat_history" not in st.session_state:
    st.session_state.chat_history = []
if "loading" not in st.session_state:
    st.session_state.loading = False

if uploaded_file is not None:
    # Save the uploaded file temporarily
    file_path = os.path.join("temp", uploaded_file.name)
    with open(file_path, "wb") as f:
        f.write(uploaded_file.getbuffer())

    # Upload PDF to Pinata
    st.write("Uploading PDF to Pinata...")
    pdf_cid = upload_pdf_to_pinata(file_path)

    if pdf_cid:
        st.write(f"File uploaded to IPFS with CID: {pdf_cid}")

        # Extract PDF content
        reader = PdfReader(file_path)
        pdf_text = ""
        for page in reader.pages:
            pdf_text += page.extract_text()

        if pdf_text:
            st.text_area("PDF Content", pdf_text, height=200)

            # Allow user to ask questions about the PDF
            user_input = st.text_input("Ask something about the PDF:", disabled=st.session_state.loading)

            if st.button("Send", disabled=st.session_state.loading):
                if user_input:
                    # Set loading state to True
                    st.session_state.loading = True

                    # Display loading indicator
                    with st.spinner("AI is thinking..."):
                        # Simulate loading with sleep (remove in production)
                        time.sleep(1)  # Simulate network delay
                        # Get AI response
                        response = get_openai_response(user_input, pdf_text)

                    # Update chat history
                    st.session_state.chat_history.append({"user": user_input, "ai": response})

                    # Clear the input box after sending
                    st.session_state.input_text = ""

                    # Reset loading state
                    st.session_state.loading = False

            # Display chat history
            if st.session_state.chat_history:
                for chat in st.session_state.chat_history:
                    st.write(f"**You:** {chat['user']}")
                    st.write(f"**AI:** {chat['ai']}")

                # Auto-scroll to the bottom of the chat
                st.write("<style>div.stChat {overflow-y: auto;}</style>", unsafe_allow_html=True)

                # Add three dots as a loading indicator if still waiting for response
                if st.session_state.loading:
                    st.write("**AI is typing** ...")

        else:
            st.error("Could not extract text from the PDF.")
    else:
        st.error("Failed to upload PDF to Pinata.")

Schritt 5: Ausführen der App

Um die App lokal auszuführen, verwenden Sie den folgenden Befehl:

streamlit run app.py

Unsere Datei wurde erfolgreich auf die Pinata-Plattform hochgeladen:

Schritt 6: Erklären des Codes

Pinata-Upload

• Der Benutzer lädt eine PDF-Datei hoch, die vorübergehend lokal gespeichert und mithilfe der Funktion upload_pdf_to_pinata auf Pinata hochgeladen wird. Pinata gibt einen Hash (CID) zurück, der die auf IPFS gespeicherte Datei darstellt.

PDF-Extraktion

• 檔案上傳後，將使用 PyPDF2 擷取 PDF 的內容。然後該文字將顯示在文字區域中。

OpenAI 互動

• 使用者可以使用文字輸入詢問有關 PDF 內容的問題。 get_openai_response 函數將使用者的查詢連同 PDF 內容傳送到 OpenAI，OpenAI 傳回相關回應。

最終程式碼可在此 github 儲存庫中找到：
https://github.com/Jagroop2001/chat-with-pdf

這就是本部落格的全部內容了！請繼續關注更多更新並繼續建立令人驚嘆的應用程式！ ?✨
快樂編碼！ ？

Das obige ist der detaillierte Inhalt vonChatten Sie mit Ihrem PDF mit Pinata, OpenAI und Streamlit. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!