Bauen Sie einen KI -Chatbot mit Python und der OpenAI -API auf

https://www.youtube.com/watch?v=9Rej66crlcm

Das programmgesteuerte Lernen, direkt mit KI zu arbeiten, eröffnet eine Welt von Möglichkeiten, die ChatGPT in einem Browser verwenden. Wenn Sie verstehen, wie Sie mithilfe von APIs (Utility Programming Interfaces) eine Verbindung zu KI -Diensten herstellen können, können Sie benutzerdefinierte Anwendungen erstellen, KI in vorhandene Systeme integrieren und personalisierte Erfahrungen erstellen, die Ihren genauen Anforderungen entsprechen.

In diesem praktischen Tutorial erstellen wir mit Python und der OpenAI-API einen voll funktionsfähigen Chatbot von Grund auf neu. Sie lernen, Gespräche zu verwalten, die Kosten mit Token -Budgetierung zu kontrollieren und benutzerdefinierte KI -Persönlichkeiten zu erstellen, die über mehrere Börsen hinweg bestehen. Am Ende haben Sie sowohl einen arbeitenden Chatbot als auch die grundlegenden Fähigkeiten, um anspruchsvollere AI-betriebene Anwendungen aufzubauen.

Warum Ihren eigenen Chatbot erstellen?

Während KI -Instruments wie ChatGPT leistungsstark sind, vermittelt der Erstellen Ihres eigenen Chatbot Ihre wesentlichen Fähigkeiten für die Arbeit mit AI -APIs professionell. Sie werden verstehen, wie das Gesprächsgedächtnis tatsächlich funktioniert, lernen, die API -Kosten effektiv zu verwalten und die Möglichkeit zu erlangen, das KI -Verhalten für bestimmte Anwendungsfälle anzupassen.

Dieses Wissen übersetzt sich direkt auf reale Anwendungen: Kundendienst-Bots mit der Stimme Ihres Unternehmens, Bildungsassistenten für bestimmte Themen oder persönliche Produktivitätstools, die Ihren Workflow verstehen.

Was du lernen wirst

Am Ende dieses Tutorials werden Sie wissen, wie man:

• Stellen Sie mit der sicheren Authentifizierung eine Verbindung zur OpenAI -API her
• Entwerfen Sie benutzerdefinierte KI -Persönlichkeiten mit Systemaufforderungen
• Erstellen Sie Gesprächsschleifen, die sich an den an früheren Austausch erinnern
• Token Counting und Price range Administration implementieren
• Struktur Chatbot -Code mit Funktionen und Klassen
• Behandeln Sie API -Fehler und Randfälle anmutig
• Stellen Sie Ihren Chatbot für andere ein

Bevor Sie beginnen: Setup Information

Voraussetzungen

Sie müssen sich mit Python -Grundlagen wie Definieren von Variablen, Funktionen, Schleifen und Wörterbüchern wohl fühlen. Es ist besonders wichtig, mit der Definition Ihrer eigenen Funktionen vertraut zu sein. Grundkenntnisse über APIs sind hilfreich, aber nicht erforderlich – wir werden das abdecken, was Sie wissen müssen.

Umgebungsaufbau

Erstens benötigen Sie eine lokale Entwicklungsumgebung. Wir empfehlen Vs Code Wenn Sie jedoch neu in der lokalen Entwicklung sind, allerdings Python ide wird funktionieren.

Installieren Sie die erforderlichen Bibliotheken mit diesem Befehl in Ihrem Terminal:

pip set up openai tiktoken

API -Schlüssel -Setup

Sie haben zwei Optionen für den Zugriff auf KI -Modelle:

Kostenlose Choice: Melden Sie sich an für Zusammen aiwas $ 1 in kostenlosen Credit liefert – mehr als genug für das gesamte Tutorial. Ihr kostenloses Modell ist langsamer, kostet aber nichts.

Premium -Choice: Verwenden Openai direkt. Das Modell, das wir verwenden (GPT-4O-Mini), ist äußerst erschwinglich-unsere gesamten Tutorialkosten bei den Checks weniger als 5 Cent.

Kritische Sicherheitsnotiz: Niemals Hardcode -API -Schlüssel in Ihren Skripten. Wir werden verwenden Umgebungsvariablen um sie sicher zu halten.

Setzen Sie für Home windows -Benutzer Ihre Umgebungsvariable durch Einstellungen > UmgebungsvariablenStarten Sie dann Ihren Laptop neu. Mac- und Linux -Benutzer können Umgebungsvariablen ohne Neustart festlegen.

Teil 1: Ihre erste AI -Antwort

Beginnen wir mit dem einfachsten Chatbot, der auf eine einzelne Nachricht reagieren kann. Diese Stiftung wird Ihnen die Kernkonzepte beibringen, bevor wir Komplexität hinzufügen.

Erstellen Sie eine neue Datei mit dem Namen chatbot.py und fügen Sie diesen Code hinzu:

import os
from openai import OpenAI

# Load API key securely from atmosphere variables
api_key = os.getenv("OPENAI_API_KEY") or os.getenv("TOGETHER_API_KEY")

# Create the OpenAI shopper
shopper = OpenAI(api_key=api_key)

# Ship a message and get a response
response = shopper.chat.completions.create(
    mannequin="gpt-4o-mini",  # or "meta-llama/Llama-3.3-70B-Instruct-Turbo-Free" for Collectively
    messages=(
        {"position": "system", "content material": "You're a fed up and sassy assistant who hates answering questions."},
        {"position": "person", "content material": "What's the climate like right now?"}
    ),
    temperature=0.7,
    max_tokens=100
)

# Extract and show the reply
reply = response.decisions(0).message.content material
print("Assistant:", reply)

Führen Sie dieses Skript aus und Sie werden so etwas wie:

Assistent: Oh fantastisch, eine weitere Wetterfrage! Ich habe keinen Zugriff auf Echtzeit-Wetterdaten, aber hier ist eine wilde Idee-vielleicht schauen Sie außerhalb Ihres Fensters oder überprüfen Sie eine Wetter-App wie alle anderen?

Den Code verstehen

Die Magie passiert in der messages Parameter, der drei verschiedene Rollen verwendet:

• System: Legt die Persönlichkeit und das Verhalten der KI fest. Dies ist so, als würde man der KI einen Charakter -Briefing geben, der jede Antwort beeinflusst.
• Benutzer: Repräsentiert, was Sie (oder Ihre Benutzer) in den Chatbot eingeben.
• Assistent: Die Antworten der KI (wir werden diese später für das Gesprächsgedächtnis hinzufügen).

Schlüsselparameter erklärt

Temperatur kontrolliert die „Kreativität der KI“. Niedrigere Werte (0-0.3) erzeugen konsistente, vorhersehbare Antworten. Höhere Werte (0,7-1,0) erzeugen kreativere, aber potenziell unvorhersehbare Outputs. Wir verwenden 0,7 als gutes Gleichgewicht.

Max -Token Begrenzt die Antwortlänge und schützt Ihr Price range. Jedes Token entspricht ungefähr zwischen 1/2 und 1 Wort, sodass 100 Token erhebliche Antworten ermöglichen und gleichzeitig die Ausreißerkosten verhindern.

Teil 2: AI -Variabilität verstehen

Führen Sie Ihr Skript mehrmals aus und bemerken Sie, wie sich die Antworten jedes Mal unterscheiden. Dies geschieht, weil KI -Modelle statistische Stichproben verwenden – sie wählen nicht nur das „beste“ Wort, sondern wählen zufällig aus den wahrscheinlichen Optionen basierend auf dem Kontext.

Lassen Sie uns damit experimentieren, indem wir unsere Temperatur modifizieren:

# Attempt temperature=0 for constant responses
temperature=0,
max_tokens=100

Führen Sie diese Model mehrmals aus und beobachten Sie konsistentere (wenn auch nicht identische) Antworten.

Versuchen Sie nun temperature=1.0 Und sehen Sie, wie viel kreativer und unvorhersehbarer die Antworten werden. Höhere Temperaturen führen häufig auch zu längeren Antworten, was uns zu einer wichtigen Lektion über das Kostenmanagement bringt.

Erkenntnisse lernen: Während der Entwicklung für ein anderes Projekt habe ich versehentlich $ 20 für einen einzelnen API -Anruf ausgegeben, weil ich vergessen habe, festzulegen max_tokens Bei der Bearbeitung einer großen Datei. Fügen Sie beim Experimentieren immer Token -Grenzen ein!

Teil 3: Refactoring mit Funktionen

Wenn Ihr Chatbot komplexer wird, wird das Organisieren von Code von entscheidender Bedeutung. Lassen Sie uns unser Skript umfunktionieren, um Funktionen und globale Variablen zu verwenden.

Ändern Sie Ihre app.py Code:

import os
from openai import OpenAI

# Configuration variables
api_key = os.getenv("OPENAI_API_KEY") or os.getenv("TOGETHER_API_KEY")
shopper = OpenAI(api_key=api_key)
MODEL = "gpt-4o-mini"  # or "meta-llama/Llama-3.3-70B-Instruct-Turbo-Free"
TEMPERATURE = 0.7
MAX_TOKENS = 100
SYSTEM_PROMPT = "You're a fed up and sassy assistant who hates answering questions."

def chat(user_input):
    """Ship a message to the AI and return the response."""
    response = shopper.chat.completions.create(
        mannequin=MODEL,
        messages=(
            {"position": "system", "content material": SYSTEM_PROMPT},
            {"position": "person", "content material": user_input}
        ),
        temperature=TEMPERATURE,
        max_tokens=MAX_TOKENS
    )

    reply = response.decisions(0).message.content material
    return reply

# Check the perform
print(chat("How are you doing right now?"))

Dieses Refactoring macht unseren Code pflegender und wiederverwendbarer. Globale Variablen lassen uns die Konfiguration einfach anpassen, während die Funktion die Chat -Logik für die Wiederverwendung zusammenfasst.

Teil 4: Gesprächsgedächtnis hinzufügen

Echte Chatbots erinnern sich an frühere Börsen. Fügen wir Konversationsspeicher hinzu, indem Sie eine wachsende Liste von Nachrichten beibehalten.

Erstellen part3_chat_loop.py:

import os
from openai import OpenAI

# Configuration
api_key = os.getenv("OPENAI_API_KEY") or os.getenv("TOGETHER_API_KEY")
shopper = OpenAI(api_key=api_key)
MODEL = "gpt-4o-mini"
TEMPERATURE = 0.7
MAX_TOKENS = 100
SYSTEM_PROMPT = "You're a fed up and sassy assistant who hates answering questions."

# Initialize dialog with system immediate
messages = ({"position": "system", "content material": SYSTEM_PROMPT})

def chat(user_input):
    """Add person enter to dialog and get AI response."""
    # Add person message to dialog historical past
    messages.append({"position": "person", "content material": user_input})

    # Get AI response utilizing full dialog historical past
    response = shopper.chat.completions.create(
        mannequin=MODEL,
        messages=messages,
        temperature=TEMPERATURE,
        max_tokens=MAX_TOKENS
    )

    reply = response.decisions(0).message.content material

    # Add AI response to dialog historical past
    messages.append({"position": "assistant", "content material": reply})

    return reply

# Interactive chat loop
whereas True:
    user_input = enter("You: ")
    if user_input.strip().decrease() in {"exit", "stop"}:
        break

    reply = chat(user_input)
    print("Assistant:", reply)

Führen Sie nun Ihren Chatbot aus und stellen Sie zweimal die gleiche Frage zu stellen:

You: Hello, how are you?
Assistant: Oh unbelievable, simply dwelling the dream of answering questions I do not care about. What would you like?

You: Hello, how are you?
Assistant: Severely, once more? Look, I am right here to assist, to not alternate pleasantries all day. What do you want?

Die KI erinnert sich an Ihre vorherige Frage und antwortet entsprechend – das ist das Gesprächsgedächtnis in Aktion!

Wie Speicher funktioniert

Jedes Mal, wenn jemand eine Nachricht sendet, fügen wir sowohl die Benutzereingabe als auch die AI -Antwort an unsere hinzu messages Liste. Die API verarbeitet diesen gesamten Gesprächsgeschichte, um kontextbezogene Antworten zu generieren.

Dies schafft jedoch ein wachsendes Drawback: Längere Gespräche bedeuten mehr Token, was höhere Kosten bedeutet.

Teil 5: Token -Administration und Kostenkontrolle

Wenn Gespräche wachsen, zählt auch der Token – und Ihre Rechnung. Fügen wir das Good Token -Administration hinzu, um Ausreißerkosten zu verhindern.

Ändern part4_final.py:

import os
from openai import OpenAI
import tiktoken

# Configuration
api_key = os.getenv("OPENAI_API_KEY") or os.getenv("TOGETHER_API_KEY")
shopper = OpenAI(api_key=api_key)
MODEL = "gpt-4o-mini"
TEMPERATURE = 0.7
MAX_TOKENS = 100
TOKEN_BUDGET = 1000  # Most tokens to maintain in dialog
SYSTEM_PROMPT = "You're a fed up and sassy assistant who hates answering questions."

# Initialize dialog
messages = ({"position": "system", "content material": SYSTEM_PROMPT})

def get_encoding(mannequin):
    """Get the suitable tokenizer for the mannequin."""
    attempt:
        return tiktoken.encoding_for_model(mannequin)
    besides KeyError:
        print(f"Warning: Tokenizer for mannequin '{mannequin}' not discovered. Falling again to 'cl100k_base'.")
        return tiktoken.get_encoding("cl100k_base")

ENCODING = get_encoding(MODEL)

def count_tokens(textual content):
    """Rely tokens in a textual content string."""
    return len(ENCODING.encode(textual content))

def total_tokens_used(messages):
    """Calculate complete tokens utilized in dialog."""
    attempt:
        return sum(count_tokens(msg("content material")) for msg in messages)
    besides Exception as e:
        print(f"(token rely error): {e}")
        return 0

def enforce_token_budget(messages, finances=TOKEN_BUDGET):
    """Take away previous messages if dialog exceeds token finances."""
    attempt:
        whereas total_tokens_used(messages) > finances:
            if len(messages) <= 2:  # Maintain system immediate + at the least one alternate
                break
            messages.pop(1)  # Take away oldest non-system message
    besides Exception as e:
        print(f"(token finances error): {e}")

def chat(user_input):
    """Chat with reminiscence and token administration."""
    messages.append({"position": "person", "content material": user_input})

    response = shopper.chat.completions.create(
        mannequin=MODEL,
        messages=messages,
        temperature=TEMPERATURE,
        max_tokens=MAX_TOKENS
    )

    reply = response.decisions(0).message.content material
    messages.append({"position": "assistant", "content material": reply})

    # Prune previous messages if over finances
    enforce_token_budget(messages)

    return reply

# Interactive chat with token monitoring
whereas True:
    user_input = enter("You: ")
    if user_input.strip().decrease() in {"exit", "stop"}:
        break

    reply = chat(user_input)
    print("Assistant:", reply)
    print(f"Present tokens: {total_tokens_used(messages)}")

Wie das Token -Administration funktioniert

Das Token -Administration -System funktioniert in mehreren Schritten:

1. Zählen Sie Token: Wir verwenden Tiktoken, um Token in jeder Nachricht genau zu zählen
2. Gesamtsumme überwachen: Verfolgen Sie die gesamten Token im gesamten Gespräch
3. Price range erzwingen: Wenn wir unser Token -Price range überschreiten, entfernen Sie automatisch die ältesten Nachrichten (halten Sie das System jedoch auf.

Erkenntnisse lernen: Verschiedene Modelle verwenden unterschiedliche Tokenisierungsschemata. Das Wort „Hund“ könnte 1 Token in einem Modell sein, aber 2 Token in einem anderen. Unsere Codierungsfunktionen erledigen diese Unterschiede anmutig.

Führen Sie Ihren Chatbot aus und führen Sie ein langes Gespräch. Beobachten Sie, wie der Token -Zähler wächst, und bemerken Sie dann, wenn er abfällt, wenn alte Nachrichten beschnitten werden. Der Chatbot behält den jüngsten Kontext bei, während er im Price range bleibt.

Teil 6: produktionsbereite Codestruktur

Für Produktionsanwendungen bietet objektorientiertes Design eine bessere Organisation und Kapselung. So konvertieren Sie unseren Funktionscode in einen klassenbasierten Ansatz:

Erstellen oop_chatbot.py:

import os
import tiktoken
from openai import OpenAI

class Chatbot:
    def __init__(self, api_key, mannequin="gpt-4o-mini", temperature=0.7, max_tokens=100,
                 token_budget=1000, system_prompt="You're a useful assistant."):
        self.shopper = OpenAI(api_key=api_key)
        self.mannequin = mannequin
        self.temperature = temperature
        self.max_tokens = max_tokens
        self.token_budget = token_budget
        self.messages = ({"position": "system", "content material": system_prompt})
        self.encoding = self._get_encoding()

    def _get_encoding(self):
        """Get tokenizer for the mannequin."""
        attempt:
            return tiktoken.encoding_for_model(self.mannequin)
        besides KeyError:
            print(f"Warning: No tokenizer discovered for mannequin '{self.mannequin}'. Falling again to 'cl100k_base'.")
            return tiktoken.get_encoding("cl100k_base")

    def _count_tokens(self, textual content):
        """Rely tokens in textual content."""
        return len(self.encoding.encode(textual content))

    def _total_tokens_used(self):
        """Calculate complete tokens in dialog."""
        attempt:
            return sum(self._count_tokens(msg("content material")) for msg in self.messages)
        besides Exception as e:
            print(f"(token rely error): {e}")
            return 0

    def _enforce_token_budget(self):
        """Take away previous messages if over finances."""
        attempt:
            whereas self._total_tokens_used() > self.token_budget:
                if len(self.messages) <= 2:
                    break
                self.messages.pop(1)
        besides Exception as e:
            print(f"(token finances error): {e}")

    def chat(self, user_input):
        """Ship message and get response."""
        self.messages.append({"position": "person", "content material": user_input})

        response = self.shopper.chat.completions.create(
            mannequin=self.mannequin,
            messages=self.messages,
            temperature=self.temperature,
            max_tokens=self.max_tokens
        )

        reply = response.decisions(0).message.content material
        self.messages.append({"position": "assistant", "content material": reply})

        self._enforce_token_budget()
        return reply

    def get_token_count(self):
        """Get present token utilization."""
        return self._total_tokens_used()

# Utilization instance
api_key = os.getenv("OPENAI_API_KEY") or os.getenv("TOGETHER_API_KEY")
if not api_key:
    increase ValueError("No API key discovered. Set OPENAI_API_KEY or TOGETHER_API_KEY.")

bot = Chatbot(
    api_key=api_key,
    system_prompt="You're a fed up and sassy assistant who hates answering questions."
)

whereas True:
    user_input = enter("You: ")
    if user_input.strip().decrease() in {"exit", "stop"}:
        break

    response = bot.chat(user_input)
    print("Assistant:", response)
    print("Present tokens used:", bot.get_token_count())

Der klassenbasierte Ansatz verkauft alle Chatbot-Funktionen, macht den Code besser gewartet und bietet eine saubere Schnittstelle für die Integration in größere Anwendungen.

Testen Sie Ihren Chatbot

Führen Sie Ihren fertigen Chatbot aus und testen Sie diese Szenarien:

1. Speichertest: Stellen Sie eine Frage und wenden Sie sich später im Gespräch darauf zurück
2. Persönlichkeitstest: Überprüfen Sie, ob die freche Persona über den Börsen hinweg konsistent bleibt
3. Token -Administration -Check: Führen Sie ein langes Gespräch und sehen Sie Token -Zählungen stabilisieren
4. Fehlerbehandlungstest: Versuchen Sie ungültige Eingaben, um anmutiger Fehlerbehandlungen zu sehen

Häufige Probleme und Lösungen

Umgebungsvariable Probleme: Wenn Sie Authentifizierungsfehler erhalten, überprüfen Sie, ob Ihre API -Style korrekt festgelegt ist. Home windows -Benutzer müssen möglicherweise nach dem Einstellen von Umgebungsvariablen neu gestartet werden.

Token zählen Unstimmigkeiten: Verschiedene Modelle verwenden unterschiedliche Tokenisierung. Unsere Fallback -Codierung liefert angemessene Schätzungen, wenn genaue Tokenisierer nicht verfügbar sind.

Speicherverwaltung: Wenn sich Gespräche wiederholend anfühlen, ist Ihr Token -Price range möglicherweise zu niedrig, was dazu führt, dass ein wichtiger Kontext zu aggressiv beschnitten wird.

Was kommt als nächstes?

Sie haben jetzt einen voll funktionsfähigen Chatbot mit Speicher, Persönlichkeit und Kostenkontrollen. Hier sind natürliche nächste Schritte:

Sofortige Erweiterungen

• Webschnittstelle: Bereitstellen mit Streamlit oder Gradio für eine benutzerfreundliche Schnittstelle
• Mehrere Persönlichkeiten: Erstellen Sie verschiedene Systemaufforderungen für verschiedene Anwendungsfälle
• Gesprächsexport: Speichern Sie Gespräche in JSON -Dateien für die Persistenz
• Nutzungsanalyse: Verfolgen Sie die Nutzung und Kosten für Token im Laufe der Zeit

Erweiterte Funktionen

• Help für Multimodell: Vergleichen Sie Antworten aus verschiedenen KI -Modellen
• Benutzerdefinierte Kenntnisse: Integrieren Sie Ihre eigenen Dokumente oder Datenquellen
• Sprachschnittstelle: Fügen Sie Sprach- und Textual content-zu-Speech-Funktionen hinzu
• Benutzerauthentifizierung: Unterstützung mehrerer Benutzer mit separaten Konversationshistorien

Produktionsüberlegungen

• Ratenbeschränkung: API -Charge -Grenzen anmutig behandeln
• Überwachung: Fügen Sie Protokollierung und Fehlerverfolgung hinzu
• Skalierbarkeit: Design für mehrere gleichzeitige Benutzer
• Sicherheit: Implementieren Sie die richtige Eingabevalidierung und -Seinheit

Key Takeaways

Der Aufbau Ihres eigenen Chatbots vermittelt grundlegende Fähigkeiten für die Arbeit mit AI -APIs professionell. Sie haben gelernt, den Gesprächszustand zu verwalten, die Kosten durch Token -Budgetierung und Strukturcode für die Wartbarkeit zu kontrollieren.

Diese Fähigkeiten übertragen direkt auf Produktionsanwendungen: Kundendienst-Bots, Bildungsassistenten, kreative Schreibwerkzeuge und unzählige andere AI-betriebene Anwendungen.

Der Chatbot, den Sie aufgebaut haben, ist ein solides Fundament. Mit den Techniken, die Sie gemeistert haben – API -Integration, Speicherverwaltung und Kostenkontrolle – sind Sie bereit, anspruchsvollere KI -Projekte anzugehen und die Konversations -KI in Ihre eigenen Anwendungen zu integrieren.

Denken Sie daran, mit verschiedenen Persönlichkeiten, Temperatureinstellungen und Token -Budgets zu experimentieren, um herauszufinden, was für Ihren spezifischen Anwendungsfall am besten funktioniert. Die wahre Kraft, einen eigenen Chatbot zu erstellen, liegt in dieser Anpassungsfähigkeit, die Sie einfach nicht durch die Verwendung der KI -Schnittstelle eines anderen erhalten können.

Ressourcen und nächste Schritte

• Vollständiger Code: Alle Beispiele sind in der erhältlich Lösungsnotizbuch
• Unterstützung der Gemeinschaft: Schließen Sie sich dem an Dataquest -Neighborhood Um Ihre Projekte zu besprechen und Hilfe bei Erweiterungen zu erhalten
• Verwandtes Lernen: Erforschen Sie die API -Integrationsmuster und fortschrittliche Python -Techniken, um noch anspruchsvollere Anwendungen zu erstellen

Experimentieren Sie mit Ihrem neuen Chatbot und denken Sie daran, dass jedes Gespräch eine Lernmöglichkeit für Sie und Ihren KI -Assistenten ist!