Erstellen Sie Ihre erste LLM -Anwendung: Ein Anfänger -Tutorial

Haben Sie jemals versucht, Ihr eigenes großes Sprachmodell (LLM) zu erstellen? Haben Sie sich jemals gefragt, wie Menschen ihre eigene LLM -Anwendung stellen, um ihre Produktivität zu steigern? LLM -Anwendungen haben sich in jeder Hinsicht als nützlich erwiesen. Der Aufbau einer LLM -App ist jetzt in der Reichweite eines jeden. Dank der Verfügbarkeit von KI -Modellen sowie leistungsstarken Frameworks. In diesem Tutorial werden wir unsere erste LLM -Bewerbung auf die so leistungsstarke Weise erstellen. Beginnen wir den Prozess. Wir werden jeden Prozess von Idee zu Code zu Code einzeln eingehen.

Inhaltsverzeichnis

• Warum LLM -Apps wichtig?
• Schlüsselkomponenten einer LLM -Anwendung
• Auswählen der richtigen Werkzeuge
• Schritt -für -Schritt -Implementierung
  • 1. Einrichten von Python und seiner Umgebung
  • 2. Installieren der erforderlichen Abhängigkeiten
  • 1. Importieren aller Abhängigkeiten
  • 4. Umgebungsaufbau
  • 5. Agent Setup
  • 6. Stromlit UI
  • 7. Ausführen der Anwendung
• Abschluss
• Häufig gestellte Fragen

Warum LLM -Apps wichtig?

LLM -Anwendungen sind insofern einzigartig, als sie natürliche Sprache verwenden, um den Benutzer zu verarbeiten und auch in natürlicher Sprache zu reagieren. Darüber hinaus sind LLM -Apps den Kontext der Benutzerabfrage kennen und entsprechend beantworten. Häufige Anwendungsfälle von LLM -Anwendungen sind Chatbots, Inhaltsgenerierung und Q & A -Agenten. Es wirkt sich erheblich auf die Benutzererfahrung aus, indem es die Konversations -KI, den Treiber der heutigen KI -Landschaft, einbezieht.

Schlüsselkomponenten einer LLM -Anwendung

Das Erstellen einer LLM -Anwendung umfasst Schritte, in denen wir verschiedene Komponenten der LLM -Anwendung erstellen. Am Ende verwenden wir diese Komponenten, um eine vollwertige Anwendung zu erstellen. Lassen Sie uns von ihnen nacheinander erfahren, um eine vollständige Verständnis jeder Komponente gründlich zu erhalten.

1. Grundmodell: Dies beinhaltet die Auswahl Ihres grundlegenden KI -Modells oder LLM, das Sie in Ihrer Anwendung im Backend verwenden. Betrachten Sie dies als das Gehirn Ihrer Anwendung.
2. Prompt Engineering: Dies ist die wichtigste Komponente, die Ihrem LLM -Kontext über Ihre Anwendung verleiht. Dies beinhaltet das Definieren des Tons, der Persönlichkeit und der Persönlichkeit Ihres LLM, damit er entsprechend antworten kann.
3. Orchestrierungsschicht: Frameworks wie Langchain, Llamaindex fungieren als Orchestrierungsschicht, die alle LLM -Anrufe und Ausgaben für Ihre Anwendung abwickelt. Diese Frameworks binden Ihre Anwendung mit LLM, damit Sie einfach auf AI -Modelle zugreifen können.
4. Tools: Tools fungieren als wichtigste Komponente beim Erstellen Ihrer LLM -App. Diese Tools werden häufig von LLMs verwendet, um Aufgaben auszuführen, die KI -Modelle nicht direkt ausführen können.

Auswählen der richtigen Werkzeuge

Die Auswahl der richtigen Tools ist eine der wichtigsten Aufgaben zum Erstellen einer LLM -Anwendung. Menschen überspringen diesen Teil des Prozesses häufig und beginnen mit der Erstellung einer LLM -Anwendung von Grund auf mit allen verfügbaren Tools. Dieser Ansatz ist sehr vage. Man sollte Tools effizient definieren, bevor man in die Entwicklungsphase eingeht. Lassen Sie unsere Werkzeuge definieren.

1. Auswahl eines LLM: Ein LLM fungiert als Geist hinter Ihrer Bewerbung. Die Auswahl des richtigen LLM ist ein entscheidender Schritt, bei dem die Kosten- und Verfügbarkeitsparameter im Auge behalten. Sie können LLMs von OpenAI, COQ und Google verwenden. Sie müssen einen API -Schlüssel von ihrer Plattform sammeln, um diese LLMs zu verwenden.
2. Frameworks: Die Frameworks fungieren als Integration zwischen Ihrer Anwendung und der LLM. Es hilft uns bei der Vereinfachung der Eingabeaufforderungen an die LLM, die Logik verkettet, die den Workflow der Anwendung definiert. Es gibt Frameworks wie Langchain und Llamaindex, die häufig zur Erstellung einer LLM -Anwendung verwendet werden. Langchain gilt als der anfängerfreundlichste und am einfachsten zu bedienende.
3. Front-End-Bibliotheken: Python bietet gute Unterstützung für das Erstellen von Front-End für Ihre Anwendungen im minimalen Code. Bibliotheken wie Streamlit, Gradio und Chainlit verfügen über Funktionen, um Ihrer LLM -Anwendung ein schönes Frontend mit minimalem Code zu verleihen.

Schritt -für -Schritt -Implementierung

Wir haben alle grundlegenden Voraussetzungen für den Bau unserer LLM -Anwendung behandelt. Überlegen wir uns auf die tatsächliche Implementierung und schreiben Sie den Code für die Entwicklung der LLM -Anwendung von Grund auf neu. In diesem Handbuch erstellen wir eine LLM-Anwendung, die eine Abfrage als Eingabe aufnimmt, die Abfrage in Unterparts unterteilt, das Internet durchsucht und das Ergebnis dann in einen gut aussehenden Markdown-Bericht mit den verwendeten Referenzen kompiliert.

1. Einrichten von Python und seiner Umgebung

Der erste Schritt besteht darin, den Python -Dolmetscher von seiner offiziellen Website herunterzuladen und auf Ihrem System zu installieren. Vergessen Sie nicht, während der Installation die Pfadvariable hinzufügen zur Systemoption hinzufügen.

Stellen Sie außerdem sicher, dass Sie Python installiert haben, indem Sie Python in die Befehlszeile eingeben.

2. Installieren der erforderlichen Abhängigkeiten

Dieser Schritt installiert die Bibliotheksabhängigkeiten in Ihr System. Öffnen Sie Ihr Terminal und geben Sie den folgenden Befehl ein, um die Abhängigkeiten zu installieren.

 PIP Installation stromlit dotenv Langchain Langchain-Openai Langchain-Community Langchain-Core

In diesem Befehl wird das Terminal ausgeführt und alle Abhängigkeiten für das Ausführen unserer Anwendung installiert.

1. Importieren aller Abhängigkeiten

Gehen Sie nach der Installation der Abhängigkeiten zu einem IDE -Code -Editor wie dem VS -Code und öffnen Sie sie im erforderlichen Pfad. Erstellen Sie nun eine Python -Datei "app.py" und fügen Sie die folgenden Importanweisungen in die Datei ein

 importieren stromlit als st

OS importieren

aus dotenv import load_dotenv

aus Langchain_openai importieren Sie Chatopenai

von Langchain_Community.tools.tavily_search importieren tavilysearchResults

von Langchain.agents importieren agentenexecutor create_tool_calling_agent

von Langchain_core.Prompts importieren ChatpromptTemplate, MessagePlaceHolder

von Langchain_core.Messages Import Aimessage, HumanMessage

4. Umgebungsaufbau

Wir erstellen einige Umgebungsvariablen für unsere LLM und andere Tools. Erstellen Sie hierzu eine Datei ".env" im selben Verzeichnis und fügen Sie mit den Umgebungsvariablen API -Tasten hinein. In unserer LLM-Anwendung werden wir beispielsweise zwei API-Schlüssel verwenden: einen OpenAI-API-Schlüssel für unsere LLM, auf die von hier aus zugegriffen werden kann, und auf einen Tavily-API-Schlüssel, mit dem das Internet in Echtzeit gesucht werden kann, auf die von hier aus zugegriffen werden kann.

 Openai_api_key = "your_api_key"

Tavily_api_key = "your_api_key"

Schreiben Sie nun in Ihrer App.py den folgenden Code. Dieser Code lädt alle verfügbaren Umgebungsvariablen direkt in Ihre Arbeitsumgebung.

 # --- Umgebungsaufbau ---

load_dotenv ()

Openai_api_key = os.getenv ("openai_api_key")

Tavily_api_key = os.getenv ("tavily_api_key")

wenn nicht openai_api_key:

   St.Error ("? OpenAI-API-Schlüssel nicht gefunden. Bitte setzen Sie es in Ihrer .env-Datei (OpenAI_API_KEY = 'SK -...')").

Wenn nicht tavily_api_key:

   St.Error ("? Tavily API-Schlüssel nicht gefunden. Bitte setzen Sie es in Ihre .env-Datei (Tavily_API_Key = 'TVly -...')").

Wenn nicht openai_api_key oder nicht tavily_api_key:

   St.Stop ()

5. Agent Setup

Da haben wir alle Umgebungsvariablen geladen. Lassen Sie uns den Agenten -Workflow erstellen, den jede Abfrage während der Verwendung der LLM -Anwendung durchlaufen würde. Hier erstellen wir ein Tool, dh tavily suchen, das das Internet durchsucht. Ein Agent Executor, der den Agenten mit Tools ausführt.

 # --- Agent Setup ---

@St.Cache_Resource

Def get_agent_executor ():

   "" "
 
   Initialisiert und gibt den Langchain Agent Executor initialisiert und gibt zurück.

   "" "

   # 1. Definieren Sie die LLM

   llm = chatopenai (model = "gpt-4o-mini", Temperatur = 0,2, api_key = openai_api_key)

   # 2. Definieren Sie Tools (vereinfachte Deklaration)

   Werkzeuge = [

       TavilySearchResults (

           max_results = 7,

           name = "web_search",

           api_key = tavily_api_key,

           Beschreibung = "führt Websuche durch, um aktuelle Informationen zu finden."

       )

   ]

   # 3.. Aktualisierte Eingabeaufforderung Vorlage (v0.3 Best Practices)

   prompt_template = chatpromptTemplate.from_messages (

       [

           ("System", "" "

           Sie sind eine Weltklasse-KI. Geben Sie umfassende, genaue Antworten mit Markdown -Zitaten an.

           Verfahren:

           1. Dekompeten Sie Fragen in Unterausfragen dekompetenz

           2. Verwenden Sie für jedes Unterbild `web_search`

           3.. Informationen synthetisieren

           4. Zitieren Sie Quellen mit Markdown -Fußnoten

           5. Referenzliste einschließen

           Follow-up-Fragen sollten den Chat-Historie-Kontext verwenden.

           "" "),

           MessagePlaPleholder ("chat_history", optional = true),

           ("Mensch", "{Eingabe}"),

           MessagePlacePlader ("Agent_Scratchpad"),

       ]

   )

   # 4.. Agent erstellen (aktualisiert auf create_tool_calling_agent)

   Agent = create_tool_calling_agent (LLM, Tools, Eingabeaufforderung_Template)

   # 5. AgentExecutor mit moderner Konfiguration

   RETUCT agierexecutor (

       Agent = Agent,

       Werkzeuge = Werkzeuge,

       wörtlich = wahr,

       handle_paring_errors = true,

       max_iterations = 10,

       return_intermediate_steps = true

   )

Hier verwenden wir eine schnelle Vorlage, die den GPT-4O-Mini-LLM leitet, wie der Suchenteil durchzuführen, den Bericht mit Referenzen kompiliert. Dieser Abschnitt ist für alle Backend -Arbeiten Ihrer LLM -Anwendung verantwortlich. Alle Änderungen in diesem Abschnitt wirken sich direkt auf die Ergebnisse Ihrer LLM -Anwendung aus.

6. Stromlit UI

Wir haben die gesamte Backend -Logik für unsere LLM -Anwendung eingerichtet. Lassen Sie uns nun die Benutzeroberfläche für unsere Bewerbung erstellen, die für die Frontend -Ansicht unserer Bewerbung verantwortlich ist.

 # --- Stromlit UI ---

St.Set_Page_Config (page_title = "AI Research Agent?", Page_icon = "?", Layout = "Wide").

St.Markdown ("" "

<style>

   .stChatMessage {

       border-radius: 10px;

       padding: 10px;

       margin-bottom: 10px;

   }

   .stChatMessage.user {

       background-color: #E6F3FF;

   }

   .stChatMessage.assistant {

       background-color: #F0F0F0;

   }

   </style>

"" ", unafe_allow_html = true)

St.Title ("? AI Research Agent")

St.Kaption ("Ihr erweiterter KI -Assistent, um das Web zu durchsuchen, Informationen zu synthetisieren und zitierte Antworten zu geben.")

Wenn "chat_history" nicht in St.Session_State:

   St.Session_State.chat_history = []

Für Message_OBJ in St.Session_State.chat_history:

   Rollen = "Benutzer" if isinstance (message_obj, humanmessage) sonst "Assistant"

   mit St.Chat_Message (Rolle):

       St.Markdown (Message_OBJ.Content)

user_query = st.chat_input ("eine Forschungsfrage stellen ...")

Wenn user_query:

   St.Session_State.chat_history.Append (HumanMessage (content = user_query)))

   mit St.Chat_Message ("Benutzer"):

       St.Markdown (User_query)

   mit St.Chat_Message ("Assistant"):

       mit St.spinner ("? Denken & recherchieren ..."):

           versuchen:

               Agent_executor = get_agent_executor ()

               response = Agent_executor.invoke ({{

                   "Eingabe": user_query,

                   "chat_history": St.Session_state.chat_history [:-1]

               })

               Antwort = Antwort ["Ausgabe"]

               St.Session_State.chat_history.Append (AIMESSAGE (Content = Antwort))

               St.Markdown (Antwort)

           außer Ausnahme als E:

               ERROR_MESSAGE = F "Entschuldigung ist ein Fehler aufgetreten: {str (e)}"

               St.Error (ERROR_MESSAGE)

               print (f "Fehler während des Agentenaufrufs: {e}")

In diesem Abschnitt definieren wir den Titel, die Beschreibung und den Chat -Historium unserer Anwendung. Streamlit bietet eine Menge Funktionen für das Anpassen unserer Anwendung. Wir haben hier eine begrenzte Anzahl von Anpassungsoptionen verwendet, um unsere Anwendung weniger komplex zu machen. Sie können Ihre Bewerbung an Ihre Anforderungen anpassen.

7. Ausführen der Anwendung

Wir haben alle Abschnitte für unsere Bewerbung definiert, und jetzt ist es bereit für den Start. Lassen Sie uns visuell sehen, was wir erstellt haben, und die Ergebnisse analysieren.

Öffnen Sie Ihr Terminal und Ihren Typ

 streamlit run app.py

Dadurch wird Ihre Anwendung initialisiert und Sie werden in Ihren Standardbrowser umgeleitet.

Dies ist die Benutzeroberfläche Ihrer LLM -Anwendung:

Versuchen wir, unsere LLM -Anwendung zu testen

Abfrage : "Was ist die neueste Langchain -Dokumentationsversion?"

Abfrage : "Wie verändert Langchain das KI -Spiel?"

Aus den Ausgängen können wir feststellen, dass unsere LLM -Anwendung die erwarteten Ergebnisse zeigt. Detaillierte Ergebnisse mit Referenzlinks. Jeder kann auf diese Referenzlinks klicken, um auf den Kontext zuzugreifen, aus dem unser LLM die Frage beantwortet. Daher haben wir unsere erste LLM-Anwendung erfolgreich erstellt. Fühlen Sie sich frei, Änderungen in diesem Code vorzunehmen und einige komplexere Anwendungen zu erstellen, wobei dieser Code als Referenz genommen wird.

Abschluss

Das Erstellen von LLM -Anwendungen ist einfacher als je zuvor. Wenn Sie dies lesen, bedeutet dies, dass Sie über genügend Wissen verfügen, um Ihre eigenen LLM -Anwendungen zu erstellen. In diesem Handbuch haben wir die Umgebung eingerichtet, die Code, die Agentenlogik, die App -Benutzeroberfläche definiert und diese auch in eine streamlitische Anwendung umgewandelt. Dies deckt alle wichtigen Schritte bei der Entwicklung einer LLM -Anwendung ab. Versuchen Sie, mit schnellen Vorlagen, LLM -Ketten und UI -Anpassungen zu experimentieren, um Ihre Anwendung entsprechend Ihren Anforderungen personalisiert zu machen. Es ist nur der Anfang; Reichere KI-Workflows warten auf Sie, mit Agenten, Speicher und domänenspezifischen Aufgaben.

Häufig gestellte Fragen

A. Nein, Sie können mit vorgebildeten LLMs (wie GPT- oder Open-Source-Unternehmen) beginnen und sich auf ein schnelles Design und die App-Logik konzentrieren.

A. Sie vereinfachen die Erhöhungsaufforderungen, den Umgang mit Speicher und die Integration von Werkzeugen, ohne das Rad neu zu erfinden.

A. Verwenden Sie Pufferspeicherklassen in Frameworks (z. B. Langchain) oder integrieren Sie Vektordatenbanken zum Abrufen.

A. Retrieval-Augmented-Generation bringt externe Daten in den Kontext des Modells und verbessert die Reaktionsgenauigkeit auf domänenspezifischen Abfragen.

A. Beginnen Sie mit einer lokalen Demo mit Gradio und skalieren Sie dann mit den umarmenden Gesichtsräumen, der optimalen Cloud-, Heroku-, Docker- oder Cloud -Plattformen.

Das obige ist der detaillierte Inhalt vonErstellen Sie Ihre erste LLM -Anwendung: Ein Anfänger -Tutorial. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!