In diesem technischen Deep Dive zeigen wir dir, wie du einen Finanz-Faktenchecker mit dem
OpenAI Agent SDK entwickelst. Wir verwenden
Python und
FastAPI als Basis, um eine API zu erstellen. Diese FastAPI-basierte API ist in der Lage, Finanzbehauptungen (z. B. von bekannten Finanzinfluencern) mithilfe von KI-Agenten mit integrierten
Guardrails und
Websuche zu überprüfen.
Einführung#
Das
OpenAI Agent SDK ist eine neue Veröffentlichung von OpenAI, die eine einfache Möglichkeit bietet, KI-Agenten zu erstellen. Mit Features wie Tool-Aufrufen, Guardrails und Handoffs ist es ideal, um KI in „agentischer“ Weise einzusetzen.
Projektüberblick#
Was benötigen wir für den Aufbau dieses Projekts? Die Schritte sind:
- Erstellung von KI-Agenten mit spezifischen Rollen
- Implementierung von Eingabe-Guardrails zur Validierung
- Nutzung der Websuche für Fact-Checking
- Aufbau einer REST-API als Schnittstelle zum Agentensystem
Technische Architektur#
Projektstruktur#
Das Projekt hat folgende Struktur:
1agents_sdk/
2├── app/
3│ ├── __init__.py
4│ ├── models.py # Pydantic-Modelle
5│ ├── routes.py # API-Endpunkte
6│ └── agents/ # Agentendefinitionen
7│ ├── fincial_checker_agent.py
8│ └── guardrail_agent.py
9├── main.py
10└── requirements.txt
Hauptkomponenten#
Das System besteht aus zwei zentralen Komponenten:
-
Agentensystem mit zwei spezialisierten Agenten:
- Financial Facts Checker Agent: prüft finanzielle Aussagen auf Richtigkeit
- Guardrail Agent: prüft vorab, ob Eingaben finanzbezogen sind – wichtig vor allem bei öffentlich zugänglichen APIs
-
FastAPI-Backend:
- Validierung über
pydantic
- Asynchrone Endpunktverarbeitung
- Strukturierte Antwortverarbeitung
Deep Dive in die Implementierung#
1. Agentendefinition#
Der Guardrail-Agent ist die erste Prüfinstanz.
Guardrails prüfen die Eingabe, bevor sie weitergeleitet wird:
python
1@input_guardrail
2async def financial_content_guardrail(ctx: RunContextWrapper, agent: Agent, input: str | list[TResponseInputItem]) -> GuardrailFunctionOutput:
3 result = await Runner.run(guardrail_agent, input, context=ctx.context)
4 return GuardrailFunctionOutput(
5 output_info=result.final_output,
6 tripwire_triggered=not result.final_output.is_financial_content,
7 )
8
9guardrail_agent = Agent(
10 name="Guardrail check",
11 instructions="Check if the user is asking you a request that is related to financial content.",
12 output_type=FinancialContentGuardrail,
13)
Der Hauptagent, der die Finanzbehauptungen überprüft, sieht folgendermaßen aus:
python
1financial_facts_checker_agent = Agent(
2 name="Financial Facts Checker Agent",
3 handoff_description="A helpful agent that can answer whether the provided content is correct financial information.",
4 input_guardrails=[financial_content_guardrail],
5 instructions="""
6 [Anweisungen zur Überprüfung von Finanzfakten...]
7 """,
8 model="gpt-4",
9 tools=[WebSearchTool()],
10 output_type=FinancialCheckerOutput
11)
Besonderheiten dieses Agenten:
- Nutzt GPT-4 als Modell
- Integriert Websuche als Tool
- Strukturierte Ausgabe via Pydantic
- Guardrail-Vorprüfung
2. API-Implementierung#
Die API wird mit
FastAPI gebaut. Eingaben werden über
Pydantic
validiert:
python
1class FinancialContentRequest(BaseModel):
2 content: str
3
4class FinancialContentResponse(BaseModel):
5 is_correct: bool
6 reasoning: str
Der Haupt-Endpunkt:
python
1@router.post("/check-financial-content", response_model=FinancialContentResponse)
2async def check_financial_content(request: FinancialContentRequest):
3 input_items = [{"content": request.content, "role": "user"}]
4 result = await Runner.run(financial_facts_checker_agent, input_items)
5 return FinancialContentResponse(
6 is_correct=result.final_output.is_correct,
7 reasoning=result.final_output.reasoning
8 )
Hier wird der Benutzerinput validiert und an den Agenten übergeben – zentral ist Runner.run(...)
. In einer produktiven Umgebung sollten zusätzliche Eingabeprüfungen erfolgen.
Arbeiten mit dem OpenAI Agent SDK#
Zentrale Konzepte#
-
Agent Definition
- Definiert Anweisungen, Modell, Tools und Ausgabetyp
- Tools wie Websuche lassen sich direkt einbinden
-
Guardrails
- Filtern ungewollte Eingaben
- Können verkettet eingesetzt werden
-
Runner System
- Führt Agenten aus
- Verwaltet Kontext und Status
- Gibt strukturierte Ausgaben zurück
Best Practices#
Unsere Empfehlungen beim Aufbau einer Agenten-API:
-
Typsicherheit
- Alle Inputs & Outputs als Pydantic-Modelle
- Klare Antwortformate
-
Fehlerbehandlung
- Exceptions abfangen
- Sinnvolle HTTP-Codes & Fehlermeldungen liefern
-
Agenten-Design
- Klare Anweisungen
- Geeignete Modellwahl
- Passende Tools nutzen
Nutzung der API#
So kannst du den Server starten und eine Abfrage durchführen:
bash
1# Server starten
2python -m main
3
4# Beispielabfrage
5curl -X POST "http://localhost:8000/check-financial-content" \
6 -H "Content-Type: application/json" \
7 -d '{
8 "content": "Ein ETF ist dasselbe wie eine einzelne Aktie"
9 }'
Die Rückgabe sieht z. B. so aus:
json
1{
2 "is_correct": false,
3 "reasoning": "Diese Aussage ist falsch. Zwar werden sowohl ETFs als auch Einzelaktien an Börsen gehandelt, sie unterscheiden sich jedoch grundlegend..."
4}
Zusätzlich kannst du über /docs
mit dem integrierten Swagger UI testen:

Testen der API über Swagger (/docs)
Fazit#
Das OpenAI Agent SDK bietet eine starke Grundlage, um KI-gestützte Anwendungen zu bauen. In Kombination mit
FastAPI und gut durchdachten Guardrails lassen sich sichere und produktionsreife Services erstellen.
Der Finanz-Faktenchecker zeigt exemplarisch:
- Wie man ein agentenbasiertes System strukturiert
- Wie Guardrails und Input-Checks eingesetzt werden
- Wie sich APIs für solche Agenten elegant umsetzen lassen
Das gesamte Beispielprojekt findest du hier:
👉
Zum GitHub-Repo
Für Organisationen, die eigene KI-Agenten einsetzen möchten: Unsere
Agentur entwickelt maßgeschneiderte Agenten & Integrationen – perfekt abgestimmt auf deinen Business-Case.
Hinweis: Das OpenAI Agents SDK befindet sich in aktiver Entwicklung. Die Inhalte dieses Artikels entsprechen dem Stand von März 2025. Für aktuelle Informationen siehe die offizielle Dokumentation.