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.
"""
cross
def 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 Area einfache Validierungen zu definieren, wie z. B. mindestens 2 Ton-/Stilattribute oder mindestens 50 Zeichen im Textual content
• Mit einem benutzerdefinierten field_validator das 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.

Manchmal schlägt Ihr „Experiment“ fehl. Dann ändern Sie Ihre Vorgehensweise leicht und dieses andere Experiment ist viel erfolgreicher.

Genau deshalb, Vor Bei der Gestaltung unserer Endspiellösung müssen wir einfach beginnen und unsere Risiken absichern.

1. Definieren Sie ein „Funds“ oder einen Zeitrahmen. Lassen Sie uns sehen, was wir in X Wochen erreichen können, und dann entscheiden, ob und wie wir weitermachen. Normalerweise reichen 2–4 Wochen aus, um den grundlegenden PoC zu verstehen. Wenn es vielversprechend aussieht, investieren Sie weiterhin Ressourcen, um es zu verbessern.
2. Experiment-Unabhängig davon, ob Sie für Ihre Experimentierphase einen Backside-up- oder Prime-down-Ansatz wählen, besteht Ihr Ziel darin, die Ergebnisfolgerate zu maximieren. Am Ende der ersten Experimentieriteration sollten Sie einige PoC (mit denen die Stakeholder spielen können) und eine erreichte Baseline haben.
3. Retrospektive — Am Ende unserer Forschungsphase können wir die Machbarkeit, Einschränkungen und Kosten der Entwicklung einer solchen App verstehen. Dies hilft uns bei der Entscheidung, ob wir sie in die Produktion bringen und wie wir das Endprodukt und seine UX gestalten.
4. Produktisierung — Entwickeln Sie eine produktionsreife Model Ihres Projekts und integrieren Sie sie in den Relaxation Ihrer Lösung, indem Sie die standardmäßigen Finest Practices von SWE befolgen und einen Suggestions- und Datenerfassungsmechanismus implementieren.

Um den experimentorientierten Prozess intestine umzusetzen, müssen wir eine fundierte Entscheidung über die Vorgehensweise und Durchführung dieser Experimente treffen:

Lean starten: Der Backside-Up-Ansatz

Während viele Early Adopters schnell in“ Stand der Technik“ Multichain-Agentensysteme mit vollwertiger Langchain oder etwas Ähnlichem, fand ich „Der Backside-Up-Ansatz“ führt oft zu besseren Ergebnissen.

Schlank anfangen, sehr magerumarmend die „Eine Aufforderung, sie alle zu knechten“ Philosophie. Obwohl diese Strategie unkonventionell erscheinen magazine und wahrscheinlich zunächst schlechte Ergebnisse hervorbringen wird, etabliert sie eine Basislinie für Ihr System.

Von dort aus iterieren und verfeinern Sie Ihre Eingabeaufforderungen kontinuierlich und setzen Sie Techniken des Immediate Engineering ein, um die Ergebnisse zu optimieren. Wenn Sie Schwachstellen in Ihrer schlanken Lösung feststellen, teilen Sie den Prozess auf, indem Sie Zweige hinzufügen, um diese Mängel zu beheben.

Beim Entwerfen jedes „Blattes“ meines LLM-Workflow-Diagramms oder meiner LLM-nativen Architektur folge ich Das magische Dreieck³ um zu bestimmen, wo und wann die Zweige abgeschnitten, geteilt oder die Wurzeln verdickt werden müssen (mithilfe schneller technischer Techniken) und um mehr Zitrone auszupressen.

Um beispielsweise „SQL-Abfragen in nativer Sprache“ mit dem Backside-Up-Ansatz zu implementieren, beginnen wir damit, die Schemata naiv an den LLM zu senden und ihn aufzufordern, eine Abfrage zu generieren.

Normalerweise widerspricht dies nicht dem „Prime-Down-Ansatz“, sondern stellt einen weiteren Schritt davor dar. Dadurch können wir schnelle Erfolge erzielen und mehr Projektinvestitionen anziehen.

Das große Ganze im Voraus: Die Prime-Down-Strategie

„Wir wissen, dass der LLM-Workflow nicht einfach ist, und um unser Ziel zu erreichen, werden wir wahrscheinlich mit einem Workflow oder einer LLM-nativen Architektur enden.“

Der Prime-Down-Ansatz berücksichtigt dies und beginnt mit der Entwicklung der LLM-nativen Architektur vom ersten Tag an und der Implementierung ihrer verschiedenen Schritte/Ketten von Anfang an.

Auf diese Weise können Sie Ihre Workflow-Architektur als Ganzes testen und die ganze Zitrone auspressen, anstatt jedes Blatt einzeln zu verfeinern.

Um beispielsweise „SQL-Abfragen in nativer Sprache“ mit dem Prime-Down-Ansatz zu implementieren, beginnen wir mit dem Entwurf der Architektur, bevor wir überhaupt mit dem Coden beginnen, und springen dann zur vollständigen Implementierung:

Die richtige Stability finden

Wenn Sie anfangen, mit LLMs zu experimentieren, werden Sie wahrscheinlich an einem der Excessive beginnen (überkompliziertes Prime-Down oder supereinfaches One-Shot). In Wirklichkeit gibt es keinen Gewinner.

Im Idealfall definieren Sie ein gutes SoP¹ und modellieren einen Experten, bevor Sie das Modell codieren und damit experimentieren. In der Realität ist die Modellierung sehr schwierig; manchmal haben Sie möglicherweise keinen Zugriff auf einen solchen Experten.

Ich fand es schwierig, beim ersten Versuch eine gute Architektur/einen guten SoP¹ zu finden, additionally lohnt es sich, ein wenig zu experimentieren, bevor man zu großen Geschützen greift. Das bedeutet jedoch nicht, dass alles muß sein zu mager. Wenn Sie bereits ein vorheriges Verständnis dass etwas MUSS in kleinere Stücke zerlegt werden – tun Sie das.

In jedem Fall sollten Sie beim Entwerfen Ihrer Lösung das Paradigma des magischen Dreiecks³ nutzen und den manuellen Prozess richtig modellieren.