Definieren Sie zunächst das Ziel für jeden Agenten oder jede Eingabeaufforderung. Bleiben Sie bei ein kognitiver Prozesstyp professional Agentwie etwa: Konzeption einer Zielseite, Auswahl von Komponenten oder Generierung von Inhalten für bestimmte Abschnitte.
Klare Grenzen sorgen für Fokus und Klarheit in Ihren LLM-Interaktionen und passen sich an die Ingenieurtechniken Spitze der LLM Dreiecksprinzip.
„Jeder Schritt in unserem Ablauf ist ein eigenständiger Prozess, der zur Erfüllung unserer Aufgabe erfolgen muss.”
Vermeiden Sie beispielsweise die Kombination verschiedener kognitiver Prozesse in derselben Eingabeaufforderung, da dies zu suboptimalen Ergebnissen führen kann. Teilen Sie diese stattdessen in separate, fokussierte Agenten auf:
def generate_landing_page_concept(input_data: LandingPageInput) -> LandingPageConcept:
"""
Generate a touchdown web page idea primarily based on the enter knowledge.
This perform focuses on the inventive means of conceptualizing the touchdown web page.
"""
crossdef select_landing_page_components(idea: LandingPageConcept) -> Checklist(LandingPageComponent):
"""
Choose applicable parts for the touchdown web page primarily based on the idea.
This perform is accountable just for selecting parts,
not for producing their content material or structure.
"""
cross
def generate_component_content(element: LandingPageComponent, idea: LandingPageConcept) -> ComponentContent:
"""
Generate content material for a selected touchdown web page element.
This perform focuses on creating applicable content material primarily based on the element kind and general idea.
"""
cross
Durch die Definition klare Grenzen Für jeden Agenten können wir sicherstellen, dass jeder Schritt in unserem Workflow auf eine bestimmte mentale Aufgabe zugeschnitten ist. Dies wird Verbesserung der Qualität der Ergebnisse und mach es einfacher zu debuggen und verfeinern.
Definieren klare Ein- und Ausgabe Strukturen, um die Ziele widerzuspiegeln und explizite Datenmodelle zu erstellen. Diese Praxis berührt die LLM Triangle-Prinzipien‚ Ingenieurtechniken Und Kontextdaten Spitzen.
class LandingPageInput(BaseModel):
model: str
product_desc: str
campaign_desc: str
cta_message: str
target_audience: str
unique_selling_points: Checklist(str)class LandingPageConcept(BaseModel):
campaign_desc_reflection: str
campaign_motivation: str
campaign_narrative: str
campaign_title_types: Checklist(str)
campaign_title: str
tone_and_style: Checklist(str)
Diese Pydantisch Modelle definieren die Struktur unserer Eingabe- und Ausgabedaten und definieren Sie klare Grenzen und Erwartungen für den Agenten.
Führen Sie Validierungen durch, um die Qualität und Moderation der LLM-Ausgaben sicherzustellen. Pydantisch eignet sich hervorragend für die Implementierung dieser Leitplanken und wir können dafür seine nativen Funktionen nutzen.
class LandingPageConcept(BaseModel):
campaign_narrative: str = Area(..., min_length=50) # native validations
tone_and_style: Checklist(str) = Area(..., min_items=2) # native validations# ...remainder of the fields... #
@field_validator("campaign_narrative")
@classmethod
def validate_campaign_narrative(cls, v):
"""Validate the marketing campaign narrative towards the content material coverage, utilizing one other AI mannequin."""
response = consumer.moderations.create(enter=v)
if response.outcomes(0).flagged:
elevate ValueError("The offered textual content violates the content material coverage.")
return v
In diesem Beispiel stellen wir die Qualität unserer Anwendung durch die Definition von zwei Arten von Validierern sicher:
- Verwendung von Pydanitc’s
Areaeinfache Validierungen zu definieren, wie z. B. mindestens 2 Ton-/Stilattribute oder mindestens 50 Zeichen im Textual content - Mit einem benutzerdefinierten
field_validatordas sicherstellt, dass die generierte Erzählung unseren Richtlinien zur Inhaltsmoderation entspricht (unter Verwendung von KI)
Strukturieren Sie Ihren LLM-Workflow so, dass er menschliche kognitive Prozesse nachahmt, indem Sie komplexe Aufgaben in kleinere Schritte aufteilen, die einer logischen Abfolge folgen. Folgen Sie dazu den SOP (Standardarbeitsanweisung) Leitprinzip der LLM Triangle-Prinzipien.
„Ohne SOP kann selbst das leistungsstärkste LLM keine durchgängig hochwertigen Ergebnisse liefern.“
4.1 Erfassen Sie versteckte implizite Erkenntnissprünge
In unserem Beispiel erwarten wir, dass das Modell LandingPageConcept als Ergebnis. Indem wir das Modell auffordern, bestimmte Felder auszugeben, leiten wir das LLM ähnlich an, wie ein menschlicher Vermarkter oder Designer an die Erstellung eines Landingpage-Konzepts herangehen würde.
class LandingPageConcept(BaseModel):
campaign_desc_reflection: str # Encourages evaluation of the marketing campaign description
campaign_motivation: str # Prompts fascinated by the 'why' behind the marketing campaign
campaign_narrative: str # Guides creation of a cohesive story for the touchdown web page
campaign_title_types: Checklist(str)# Promotes brainstorming totally different title approaches
campaign_title: str # The ultimate choice on the title
tone_and_style: Checklist(str) # Defines the general really feel of the touchdown web page
Der LandingPageConcept Struktur ermutigt den LLM, einem menschlichen Denkprozess zu folgen, der die subtile gedankliche Sprünge (implizite Erkenntnis „springt“), die ein Experte instinktiv treffen würde, genau wie wir es in unserem SOP vorgelebt haben.
4.2 Aufteilung komplexer Prozesse in mehrere Schritte/Agenten
Bei komplexen Aufgaben den Prozess in mehrere Schritte unterteilen, die jeweils von einem separaten LLM-Aufruf ausgeführt werden, oder „Agent“:
async def generate_landing_page(input_data: LandingPageInput) -> LandingPageOutput:
# Step 1: Conceptualize the marketing campaign
idea = await generate_concept(input_data)# Step 2: Choose applicable parts
selected_components = await select_components(idea)
# Step 3: Generate content material for every chosen element
component_contents = {
element: await generate_component_content(input_data, idea, element)
for element in selected_components
}
# Step 4: Compose the ultimate HTML
html = await compose_html(idea, component_contents)
return LandingPageOutput(idea, selected_components, component_contents, html)
Dieser Multi-Agenten-Ansatz entspricht der Artwork und Weise, wie Menschen komplexe Probleme angehen – indem sie diese in kleinere Teile zerlegen.
YAML ist ein beliebt benutzerfreundliches Datenserialisierungsformat. Es ist so konzipiert, dass es für Menschen leicht lesbar und für Maschinen dennoch leicht zu analysieren ist – was es zum Klassiker für die LLM-Verwendung macht.
Ich habe festgestellt, dass YAML besonders effektiv für LLM-Interaktionen ist und über verschiedene Modelle hinweg viel bessere Ergebnisse liefert. Es konzentriert die Token-Verarbeitung auf wertvolle Inhalte statt auf Syntax.
YAML ist außerdem zwischen verschiedenen LLM-Anbietern wesentlich portabler und ermöglicht Ihnen die Beibehaltung eines strukturierten Ausgabeformats.
async def generate_component_content(input_data: LandingPageInput, idea: LandingPageConcept,element: LandingPageComponent) -> ComponentContent:
few_shots = {
LandingPageComponent.HERO: {
"enter": LandingPageInput(
model="Mustacher",
product_desc="Luxurious mustache cream for grooming and styling",
# ... remainder of the enter knowledge ...
),
"idea": LandingPageConcept(
campaign_title="Have a good time Dad's Sprint of Distinction",
tone_and_style=("Heat", "Barely humorous", "Nostalgic")
# ... remainder of the idea ...
),
"output": ComponentContent(
motivation="The hero part captures consideration and communicates the core worth proposition.",
content material={
"headline": "Honor Dad's Distinction",
"subheadline": "The Artwork of Mustache Care",
"cta_button": "Store Now"
}
)
},
# Add extra element examples as wanted
}sys = "Craft touchdown web page element content material. Reply in YAML with motivation and content material construction as proven."
messages = ({"position": "system", "content material": sys})
messages.lengthen((
message for instance in few_shots.values() for message in (
{"position": "consumer", "content material": to_yaml({"enter": instance("enter"), "idea": instance("idea"), "element": element.worth})},
{"position": "assistant", "content material": to_yaml(instance("output"))}
)
))
messages.append({"position": "consumer", "content material": to_yaml({"enter": input_data, "idea": idea, "element": element.worth})})
response = await consumer.chat.completions.create(mannequin="gpt-4o", messages=messages)
raw_content = yaml.safe_load(sanitize_code_block(response.decisions(0).message.content material))
return ComponentContent(**raw_content)
Beachten Sie, wie wir Beispiele mit wenigen Versuchen verwenden, um „zeigen, nicht erzählen“ das erwartete YAML-Format. Dieser Ansatz ist effektiver als explizite Anweisungen in der Eingabeaufforderung für die Ausgabestruktur.
Überlegen Sie sorgfältig, wie Sie Daten für den LLM modellieren und präsentieren. Dieser Tipp ist von zentraler Bedeutung für die Kontextdaten Spitze der LLM Triangle-Prinzipien.
„Selbst das leistungsstärkste Modell benötigt relevante und intestine strukturierte Kontextdaten, um zu glänzen.“
Werfen Sie nicht alle Daten weg, die Sie im Modell haben. Geben Sie dem Modell stattdessen die Informationen, die für das von Ihnen definierte Ziel related sind.
async def select_components(idea: LandingPageConcept) -> Checklist(LandingPageComponent):
sys_template = jinja_env.from_string("""
Your activity is to pick essentially the most applicable parts for a touchdown web page primarily based on the offered idea.
Select from the next parts:
{% for element in parts %}
- {{ element.worth }}
{% endfor %}
You MUST reply ONLY in a legitimate YAML listing of chosen parts.
""")sys = sys_template.render(parts=LandingPageComponent)
immediate = jinja_env.from_string("""
Marketing campaign title: "{{ idea.campaign_title }}"
Marketing campaign narrative: "{{ idea.campaign_narrative }}"
Tone and magnificence attributes: { be a part of(', ') }
""")
messages = ({"position": "system", "content material": sys}) + few_shots + (
{"position": "consumer", "content material": immediate.render(idea=idea)})
response = await consumer.chat.completions.create(mannequin="gpt-4", messages=messages)
selected_components = yaml.safe_load(response.decisions(0).message.content material)
return (LandingPageComponent(element) for element in selected_components)
In diesem Beispiel verwenden wir Jinja Vorlagen zum dynamischen Erstellen unserer Eingabeaufforderungen. Dadurch werden auf elegante Weise fokussierte und relevante Kontexte für jede LLM-Interaktion erstellt.
„Daten sind der Motor nativer LLM-Anwendungen. Ein strategisches Design kontextbezogener Daten erschließt ihr wahres Potenzial.“
Few-Shot-Studying ist eine unverzichtbare Technik im Immediate Engineering. Wenn dem LLM relevante Beispiele zur Verfügung gestellt werden, verbessert sich sein Verständnis der Aufgabe erheblich.
Beachten Sie, dass wir in beiden Ansätzen, die wir unten diskutieren, Wiederverwendung unserer Pydantic-Modelle für die wenigen Aufnahmen — dieser Trick sorgt für Konsistenz zwischen den Beispielen und unserer eigentlichen Aufgabe! Leider musste ich es auf die harte Tour lernen.
6.1.1 Beispiele für Few-Shot-Studying
Schauen Sie sich die few_shots Wörterbuch in Abschnitt 5. Bei diesem Ansatz:
Beispiele werden hinzugefügt zu messages als separate Benutzer- und Assistentennachrichten aufgelistet, gefolgt von der eigentlichen Benutzereingabe.
messages.lengthen((
message for instance in few_shots for message in (
{"position": "consumer", "content material": to_yaml(instance("enter"))},
{"position": "assistant", "content material": to_yaml(instance("output"))}
)
))
# then we will add the consumer immediate
messages.append({"position": "consumer", "content material": to_yaml(input_data)})
Indem wir die Beispiele so platzieren, messagesorientieren wir uns an der Trainingsmethodik von Anweisungsmodellen. Dadurch kann das Modell mehrere „Beispielinteraktionen“ sehen, bevor es die Benutzereingabe verarbeitet – und so das erwartete Eingabe-Ausgabe-Muster besser verstehen.
Wenn Ihre Anwendung wächst, können Sie weitere Few-Pictures hinzufügen, um mehr Anwendungsfälle abzudecken. Für noch anspruchsvollere Anwendungen sollten Sie die Implementierung von dynamische paar-shot Auswahl, wobei auf Grundlage der aktuellen Eingabe die relevantesten Beispiele ausgewählt werden.
6.1.2 Aufgabenspezifisches Lernen mit wenigen Stichproben
Bei dieser Methode werden Beispiele verwendet, die in direktem Zusammenhang mit der aktuellen Aufgabe stehen. innerhalb der immediate selbst. Zur Generierung zusätzlicher Alleinstellungsmerkmale dient beispielsweise diese Eingabeaufforderungsvorlage:
Generate {{ num_points }} extra distinctive promoting factors for our {{ model }} {{ product_desc }}, following this model:
{% for level in existing_points %}
- {{ level }}
{% endfor %}
Dies bietet eine gezielte Anleitung für bestimmte Aufgaben zur Inhaltserstellung durch die Einbeziehung der Beispiele direkt in der Eingabeaufforderung und nicht als separate Nachrichten.
Während ausgefallene Immediate-Engineering-Techniken wie „Gedankenbaum“ oder „Gedankengraph“ vor allem für die Forschung interessant sind, fand ich sie für die Produktion ziemlich unpraktisch und oft übertrieben. Konzentrieren Sie sich bei echten Anwendungen auf den Entwurf einer geeigneten LLM-Architektur (auch bekannt als Workflow-Engineering).
Dies gilt auch für die Verwendung von Agenten in Ihren LLM-Anwendungen. Es ist wichtig, den Unterschied zwischen Standardagenten und autonomen Agenten zu verstehen:
Vertreter: „Convey mich von A → B, indem du XYZ tue.“
Autonome Agenten:„Convey mich von A → B, indem du etwas tust, es ist mir egal wie.“
Autonome Agenten bieten zwar Flexibilität und schnellere Entwicklung, können aber auch Unvorhersehbarkeit und Debugging-Herausforderungen mit sich bringen. Verwenden Sie autonome Agenten mit Bedacht – nur, wenn die Vorteile überwiegen deutlich der potenzielle Kontrollverlust und die zunehmende Komplexität.
Kontinuierliches Experimentieren ist für die Verbesserung Ihrer LLM-nativen Anwendungen unerlässlich. Lassen Sie sich von der Idee von Experimenten nicht einschüchtern – sie können so klein sein wie das Anpassen einer Eingabeaufforderung. Wie in „Erstellen von LLM-Apps: Eine klare Schritt-für-Schritt-Anleitung“, Es ist entscheidend, eine Basislinie festlegen Und Verfolgen Sie entsprechende Verbesserungen.
Wie alles andere in der „KI“ erfordern LLM-native Apps eine Forschung und Experimente Denkweise.
Ein weiterer guter Trick besteht darin, Ihre Eingabeaufforderungen an einem schwächeren Modell auszuprobieren als dem, das Sie in der Produktion verwenden möchten (z. B. Open-Supply-8B-Modelle) – eine Eingabeaufforderung mit „okayer“ Leistung bei einem kleineren Modell wird bei einem größeren Modell viel besser funktionieren.