Einen Finanz-Faktenchecker mit dem OpenAI Agent SDK bauen

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:

agents_sdk/
├── app/
│   ├── __init__.py
│   ├── models.py      # Pydantic-Modelle
│   ├── routes.py      # API-Endpunkte
│   └── agents/        # Agentendefinitionen
│       ├── fincial_checker_agent.py
│       └── guardrail_agent.py
├── main.py
└── 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:

@input_guardrail
async def financial_content_guardrail(ctx: RunContextWrapper, agent: Agent, input: str | list[TResponseInputItem]) -> GuardrailFunctionOutput:
    result = await Runner.run(guardrail_agent, input, context=ctx.context)
    return GuardrailFunctionOutput(
        output_info=result.final_output,
        tripwire_triggered=not result.final_output.is_financial_content,
    )

guardrail_agent = Agent(
    name="Guardrail check",
    instructions="Check if the user is asking you a request that is related to financial content.",
    output_type=FinancialContentGuardrail,
)

Der Hauptagent, der die Finanzbehauptungen überprüft, sieht folgendermaßen aus:

financial_facts_checker_agent = Agent(
    name="Financial Facts Checker Agent",
    handoff_description="A helpful agent that can answer whether the provided content is correct financial information.",
    input_guardrails=[financial_content_guardrail],
    instructions="""
    [Anweisungen zur Überprüfung von Finanzfakten...]
    """,
    model="gpt-4",
    tools=[WebSearchTool()],
    output_type=FinancialCheckerOutput
)

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:

class FinancialContentRequest(BaseModel):
    content: str

class FinancialContentResponse(BaseModel):
    is_correct: bool
    reasoning: str

Der Haupt-Endpunkt:

@router.post("/check-financial-content", response_model=FinancialContentResponse)
async def check_financial_content(request: FinancialContentRequest):
    input_items = [{"content": request.content, "role": "user"}]
    result = await Runner.run(financial_facts_checker_agent, input_items)
    return FinancialContentResponse(
        is_correct=result.final_output.is_correct,
        reasoning=result.final_output.reasoning
    )

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:

# Server starten
python -m main

# Beispielabfrage
curl -X POST "http://localhost:8000/check-financial-content" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "Ein ETF ist dasselbe wie eine einzelne Aktie"
  }'

Die Rückgabe sieht z. B. so aus:

{
  "is_correct": false,
  "reasoning": "Diese Aussage ist falsch. Zwar werden sowohl ETFs als auch Einzelaktien an Börsen gehandelt, sie unterscheiden sich jedoch grundlegend..."
}

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.