azure ai-foundry multi-agent claims insurance observability

Mehrebenen-Triage von Versicherungsansprüchen mit mehreren Agenten auf Microsoft Foundry

Abwicklung von Versicherungsansprüchen in Microsoft Foundry: Ein Koordinator zusammen mit Vertretern für Versicherungsschutz, Betrugserkennung und Abwicklung, Kontrollpunkte, App Insights sowie Hosting für Container Apps.

Verlag: REACTAPP.TOPAuf dieser Website hinzugefügt 26. Sept. 202613 Min. Lesezeit2993 Wörter

Quellen: AZURE AI: Multi-agent claims triage on Microsoft Foundry

Stellen Sie sich vor, eine Versicherungsgesellschaft erhält täglich Tausende neuer Schadensmeldungen über Web-Formulare sowie transkribierte Telefonate. Vor der Zahlung sind drei Aspekte entscheidend: die Versicherungssumme zum Zeitpunkt des Ereignisses, Anzeichen für Betrug, die das SIU-Team überwacht, sowie der Ausgleichsbereich auf Basis der Schadensschätzung. Eine manuelle, sequenzielle Prüfung ist langsam. Ein von Foundry betriebenes Multi-Agent-Triage-System kann die Spezialisten parallel arbeiten lassen, während Menschen für Ausnahmefälle zur Verfügung stehen.

Eingesetzte Tools

Modellveröffentlichungen von Azure AI Foundry, ein Agent-/Orchestrierungsframework mit Übergaben, Checkpointing für zuverlässige Ausführungen, Application Insights zur Protokollierung sowie Container Apps mit verwalteter Identität für die Hostung.

Voraussetzungen

Eine Azure-Mitgliedschaft mit Zugang zu Foundry, die Fähigkeit zur Veröffentlichung von Container-Apps, ein App Insights-Arbeitsbereich sowie Beispiele für Schadensmeldungen zur Testsicherung.

Projektarchitektur

Ein Koordinationsagent leitet die Aufgaben an drei Spezialisten weiter (Abdeckung, Betrug, Abwicklung). Tools übernehmen die Abfrage von Policen, die Überprüfung von Betrugslisten sowie die Anwendung von Banding-Regeln. Zwischenzustände während einer Anfrage werden gespeichert. Telemetriedaten werden bei jeder Weitergabe übertragen.

Schritt 1: Erstellen Sie die Foundry-Ressource und die Modellbereitstellungen

Versorgen Sie das Projekt mit den notwendigen Ressourcen und bereitstellen Sie die Chatmodelle, die die Agenten verwenden werden. Notieren Sie sich sorgfältig die Namen der Bereitstellungen.

Schritt 2: Installieren Sie das Framework und weisen Sie einen Chat-Client auf Foundry hin

az group create \
  --name rg-claims-prod-uks \
  --location uksouth

az cognitiveservices account create \
  --name fdy-claims-prod-uks \
  --resource-group rg-claims-prod-uks \
  --location uksouth \
  --kind AIServices \
  --sku S0 \
  --assign-identity

az cognitiveservices account deployment create \
  --name fdy-claims-prod-uks \
  --resource-group rg-claims-prod-uks \
  --deployment-name gpt-4o \
  --model-name gpt-4o \
  --model-version 2024-08-06 \
  --model-format OpenAI \
  --sku-capacity 200 \
  --sku-name GlobalStandard

az cognitiveservices account deployment create \
  --name fdy-claims-prod-uks \
  --resource-group rg-claims-prod-uks \
  --deployment-name gpt-4o-mini \
  --model-name gpt-4o-mini \
  --model-version 2024-07-18 \
  --model-format OpenAI \
  --sku-capacity 400 \
  --sku-name GlobalStandard

python -m venv .venv
source .venv/bin/activate
pip install agent-framework azure-monitor-opentelemetry azure-identity azure-cosmos

# claims/clients.py
import os
from azure.identity import DefaultAzureCredential
from agent_framework.azure import AzureOpenAIChatClient

credential = DefaultAzureCredential()

coordinator_client = AzureOpenAIChatClient(
    endpoint=os.environ["FOUNDRY_ENDPOINT"],
    deployment_name="gpt-4o",
    credential=credential,
)

specialist_client = AzureOpenAIChatClient(
    endpoint=os.environ["FOUNDRY_ENDPOINT"],
    deployment_name="gpt-4o-mini",
    credential=credential,
)

# claims/agents.py
from claims.clients import coordinator_client, specialist_client

coordinator = coordinator_client.create_agent(
    name="triage",
    instructions=(
        "You are the first-line claims triage officer for a UK motor insurer. "
        "Read the claim and decide which specialist should handle it next. "
        "Route to 'policy_agent' when cover or policy dates are in question. "
        "Route to 'fraud_agent' when the description contains any indicator of "
        "staged loss, late notification, or inconsistent detail. "
        "Route to 'settlement_agent' when cover is confirmed and only the payout "
        "figure remains. Call the matching handoff tool, for example "
        "handoff_to_fraud_agent. Never state a settlement figure yourself."
    ),
)

policy_agent = specialist_client.create_agent(
    name="policy_agent",
    instructions=(
        "You verify whether the policy was in force on the incident date and "
        "whether the peril is covered. Use the lookup_policy tool. State the "
        "cover position plainly and cite the policy section. If cover is void, "
        "say so and stop; do not speculate on settlement."
    ),
)

fraud_agent = specialist_client.create_agent(
    name="fraud_agent",
    instructions=(
        "You score claims against the SIU signal list using the score_fraud_signals "
        "tool. Report each signal that fired and the aggregate score. Any score at "
        "or above 0.6 must be handed to policy_agent for a cover check before it "
        "goes anywhere near settlement."
    ),
)

settlement_agent = specialist_client.create_agent(
    name="settlement_agent",
    instructions=(
        "You band the damage estimate and propose a settlement using the "
        "band_settlement tool. Anything above 15000 GBP must be flagged for human "
        "authorisation in your response. Never approve a payment."
    ),
)

# claims/workflow.py
from agent_framework import HandoffBuilder
from claims.agents import coordinator, policy_agent, fraud_agent, settlement_agent

def build_triage_workflow():
    return (
        HandoffBuilder(
            name="claims_triage",
            description="Motor claims triage: cover, fraud signals, settlement banding.",
            participants=[coordinator, policy_agent, fraud_agent, settlement_agent],
        )
        .set_coordinator(coordinator)
        .add_handoff(coordinator, [policy_agent, fraud_agent, settlement_agent])
        .add_handoff(fraud_agent, policy_agent)
        .add_handoff(policy_agent, settlement_agent)
        .with_interaction_mode("autonomous", autonomous_turn_limit=12)
        .with_termination_condition(
            lambda conv: any(
                "AUTHORISATION REQUIRED" in (msg.text or "")
                for msg in conv[-2:]
            )
        )
        .build()
    )

# claims/tools.py
from typing import Annotated
from datetime import date
import httpx

POLICY_API = "https://pas.internal.claims-leeds.co.uk/v2"

async def lookup_policy(
    policy_number: Annotated[str, "The policy number, format MOT-00000000"],
    incident_date: Annotated[str, "Incident date as YYYY-MM-DD"],
) -> dict:
    """Return cover status and policy sections in force on the incident date."""
    async with httpx.AsyncClient(timeout=10.0) as client:
        r = await client.get(
            f"{POLICY_API}/policies/{policy_number}/cover",
            params={"as_at": incident_date},
        )
        r.raise_for_status()
        return r.json()

SIU_SIGNALS = {
    "late_notification_days": 14,
    "no_police_reference": True,
    "prior_claims_12m": 2,
}

def score_fraud_signals(
    description: Annotated[str, "Free-text claim description"],
    notified_after_days: Annotated[int, "Days between incident and notification"],
    prior_claims_12m: Annotated[int, "Claims by this policyholder in last 12 months"],
) -> dict:
    """Score a claim against the SIU signal list. Returns fired signals and aggregate."""
    fired = []
    if notified_after_days > SIU_SIGNALS["late_notification_days"]:
        fired.append("late_notification")
    if prior_claims_12m >= SIU_SIGNALS["prior_claims_12m"]:
        fired.append("claim_frequency")
    if "no witnesses" in description.lower():
        fired.append("no_independent_witness")
    return {"signals_fired": fired, "score": round(len(fired) / 3, 2)}

def band_settlement(
    estimate_gbp: Annotated[float, "Repair or replacement estimate in GBP"],
) -> dict:
    """Band an estimate and return the proposed settlement and authorisation route."""
    if estimate_gbp <= 2500:
        return {"band": "A", "proposed_gbp": estimate_gbp, "route": "auto"}
    if estimate_gbp <= 15000:
        return {"band": "B", "proposed_gbp": estimate_gbp, "route": "team_leader"}
    return {"band": "C", "proposed_gbp": estimate_gbp, "route": "AUTHORISATION REQUIRED"}

policy_agent = specialist_client.create_agent(
    name="policy_agent",
    instructions="...",
    tools=[lookup_policy],
)

fraud_agent = specialist_client.create_agent(
    name="fraud_agent",
    instructions="...",
    tools=[score_fraud_signals],
)

settlement_agent = specialist_client.create_agent(
    name="settlement_agent",
    instructions="...",
    tools=[band_settlement],
)

# claims/checkpoints.py
from agent_framework import InMemoryCheckpointStorage

# Tests and local runs
storage = InMemoryCheckpointStorage()

workflow = build_triage_workflow_with_storage(storage)

async for event in workflow.run_stream(claim_text, session_id=claim_id):
    handle(event)

# claims/telemetry.py
import os
from azure.monitor.opentelemetry import configure_azure_monitor
from agent_framework.observability import enable_instrumentation

def init_telemetry() -> None:
    configure_azure_monitor(
        connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"],
    )
    enable_instrumentation()

dependencies
| where timestamp > ago(24h)
| where name startswith "invoke_agent"
| extend agent = tostring(customDimensions["gen_ai.agent.name"])
| extend claim = tostring(customDimensions["session.id"])
| summarize
    hops = count(),
    total_ms = sum(duration),
    p95_ms = percentile(duration, 95)
    by agent
| order by total_ms desc

# claims/run.py
import asyncio
from agent_framework import RequestInfoEvent
from claims.telemetry import init_telemetry
from claims.workflow import build_triage_workflow

CLAIM = """
Claim MOT-40118822. Policy MOT-00318844, incident 2026-07-29, notified 2026-08-19.
Insured reports offside wing and door damage in a supermarket car park, no witnesses,
no police reference. Third party details not supplied. Estimate 3,180 GBP.
"""

async def main() -> None:
    init_telemetry()
    workflow = build_triage_workflow()

    async for event in workflow.run_stream(CLAIM, session_id="MOT-40118822"):
        if isinstance(event, RequestInfoEvent):
            # Autonomous mode only surfaces this on escalation
            print(f"HUMAN NEEDED: {event.data.prompt}")
            break
        print(event)

asyncio.run(main())

az identity create \
  --name umi-claims-triage \
  --resource-group rg-claims-prod-uks

PRINCIPAL=$(az identity show -n umi-claims-triage -g rg-claims-prod-uks --query principalId -o tsv)
CLIENT=$(az identity show -n umi-claims-triage -g rg-claims-prod-uks --query clientId -o tsv)
FOUNDRY=$(az cognitiveservices account show -n fdy-claims-prod-uks -g rg-claims-prod-uks --query id -o tsv)

az role assignment create \
  --role "Azure AI User" \
  --assignee-object-id $PRINCIPAL \
  --assignee-principal-type ServicePrincipal \
  --scope $FOUNDRY

az containerapp create \
  --name ca-claims-triage \
  --resource-group rg-claims-prod-uks \
  --environment cae-claims-prod-uks \
  --image acrclaimsproduks.azurecr.io/claims-triage:1.0.0 \
  --user-assigned umi-claims-triage \
  --min-replicas 1 \
  --max-replicas 8 \
  --cpu 1.0 \
  --memory 2.0Gi \
  --env-vars \
    FOUNDRY_ENDPOINT=https://fdy-claims-prod-uks.openai.azure.com/ \
    AZURE_CLIENT_ID=$CLIENT \
    ENABLE_INSTRUMENTATION=true \
    OTEL_SERVICE_NAME=claims-triage \
    APPLICATIONINSIGHTS_CONNECTION_STRING=secretref:appi-conn

az group delete \
  --name rg-claims-prod-uks \
  --yes \
  --no-wait

az containerapp delete \
  --name ca-claims-triage \
  --resource-group rg-claims-prod-uks \
  --yes

az cognitiveservices account deployment delete \
  --name fdy-claims-prod-uks \
  --resource-group rg-claims-prod-uks \
  --deployment-name gpt-4o-mini

Konfigurieren Sie den Endpunkt, die Bereitstellung sowie die Authentifizierung über Entra/managed identity – vermeiden Sie es, API-Schlüssel in Containerbildern mitzuschicken.

Schritt 3: Definieren Sie den Koordinator sowie die drei Spezialisten

Geben Sie jedem Spezialisten eine präzise Systemanweisung sowie einen definierten Satz an Werkzeugen. Der Koordinator ist nur für die Weiterleitung und Aggregation zuständig; er sollte keine Logik der Spezialisten neu implementieren.

Schritt 4: Konfigurieren Sie das Übertragungsdiagramm

Eindeutige Übertragungskanten sind besser als ein chaotischer Mix an Werkzeugen. Die Abfolge „Abdeckung → Betrug → Abwicklung“ ist eine sinnvolle Standardkonfiguration; bei stark ansteigenden Betrugswerten sollte eine direkte Weiterleitung an die SIU möglich sein.

Schritt 5: Stellen Sie den Spezialisten echte Werkzeuge zur Verfügung

Die Werkzeuge müssen auf echten Systemen oder zuverlässigen Simulierungen mit entsprechenden Schemata basieren. Falsche Werkzeuge, die stets „zustimmen“, bringen keinerlei Lerneffekt.

Schritt 6: Erstellen Sie Checkpoints, damit bei einem Neustart keine laufenden Anfragen verloren gehen

Speichern Sie den Zustand der Threads/Anfragen nach jedem Schritt durch einen Spezialisten. Bei einem Neustart des Containers während einer Anfrage sollte die Bearbeitung fortgesetzt werden, nicht doppelt bezahlt.

Schritt 7: Senden Sie Spuren und Metriken an Application Insights

Erstellen Sie benutzerdefinierte Ereignisse für Übertragungen, Tool-Latenz und den Endwert. Die Dashboards sollten die mittlere Zeit bis zur Klassifizierung im Vergleich zur manuellen Referenzwertanzeige zeigen.

Schritt 8: Führen Sie eine Anfrage durch und lesen Sie das Ergebnis

Verwenden Sie eine „goldene“ Anfrage mit bekannten Deckungsinformationen und Ergebnissen bezüglich Betrugsfällen. Stellen Sie sicher, dass das endgültige Paket des Koordinators alle drei Spezialisten-Ergebnisse enthält.

Schritt 9: Implementieren Sie es in Container Apps mit verwalteter Identität

Weisen Sie der Identität Rechte für die Foundry-Implementierungen sowie für alle Backend-APIs zu, auf die die Tools zugreifen. Beschränken Sie den Zugriff streng.

Fehlerbehebung

Ein leeres Ausgabeergebnis der Spezialisten deutet in der Regel auf einen falschen Implementierungsnamen oder ein abgeschnittenes Tool-JSON hin. Schleifen entstehen oft durch fehlende Bedingungen zur Beendigung der Übertragung. Authentifizierungsfehler liegen am RBAC-System und nicht daran, dass das Modell nicht verfügbar ist.

Kosten für den Betrieb

Modell-Tokens dominieren; die Speicherung von Checkpoints sowie App Insights sind im Vergleich dazu gering. Setzen Sie eine Obergrenze für die maximale Anzahl der Schritte pro Anfrage sowie für Cache-Policy-Aufrufe.

Aufbereiten

Löschen Sie die Container-Apps, Identitäten und Bereitstellungen, die Sie für den Übungsweg erstellt haben, damit die Demo-Ressourcen nicht weiterhin in der Rechnung auftauchen.

Abschluss

Die Triage mehrerer Agenten funktioniert, wenn die Spezialisierungen begrenzt sind, die Tools real vorhanden sind, die Checkpoints langlebig sind und Telemetriedaten zeigen, dass Latenzvorteile bestehen. Foundry stellt den Modell-Host bereit; die Graphen- und Betriebsdisziplin liefern das Produkt.

Fügen Sie einen Knoten für menschliche Freigabe hinzu, um Abrechnungsbereiche über einem Schwellenwert zu verwalten. Die Agenten sollten die Triage beschleunigen, anstatt stillschweigend große Auszahlungen zu genehmigen.

Regeln zur Versionsschummelung sollten getrennt von Modell-Anweisungen gehandhabt werden. Wenn SIU eine Signalliste aktualisiert, sollte kein Anpassung der Anweisungen erforderlich sein, um dies mitzubekommen – die Tools sollten die aktuelle Liste lesen können.

Stellen Sie Lasttests für gleichzeitige Anfragen unter Berücksichtigung der Rate Limits in der Foundry-Implementierung durch. Das Verhalten bei Überlauf der Warteschlange muss definiert werden: Ablehnen, Verzögern oder Umstieg auf manuelle Bearbeitung.

Privatsphäre: Der Text der Anfragen enthält sensible Daten. Stellen Sie sicher, dass in den Protokollen keine persönlichen Identifikationsdaten wie PANs oder SSNs angegeben werden und dass App Insights bei der Stichprobenentnahme keine Rohdaten in benutzerdefinierten Dimensionen speichert.

Führen Sie einen Chaos-Test durch, bei dem der Container mitten in einer Anfrage abgeschaltet wird und anschließend ohne doppelte Nebeneffekte des Tools von einem Checkpoint wieder gestartet wird – Idempotenzschlüssel bei Schreibvorgängen sind zwingend erforderlich.

Fügen Sie einen Knoten für menschliche Freigabe hinzu, um Abrechnungsbeträge über einem bestimmten Schwellenwert zu prüfen. Die Mitarbeiter sollten die Bearbeitung beschleunigen, anstatt große Auszahlungen stillschweigend zu genehmigen.

Führen Sie die Regeln zur Erkennung von Versionsbetrug getrennt von den Modellanweisungen. Wenn SIU eine Liste von Signalen aktualisiert, sollte kein Änderung der Anweisungen erforderlich sein, um diese zu berücksichtigen – die Tools sollten die aktuelle Liste lesen.

Stellen Sie Lasttests für gleichzeitige Anfragen unter Berücksichtigung der Rate Limits bei der Foundry-Implementierung durch. Das Verhalten bei Überlauf der Warteschlange muss definiert werden: Ablehnen, Verzögern oder Umstieg auf manuelle Bearbeitung.

Spezialisten sollten das Erfinden von Richtlinienklauseln verbieten. Wenn das Abdeckungstool leere Ergebnisse liefert, muss der Spezialist die Angelegenheit weiterleiten – anstatt zu vermuten, dass die Anfrage „wahrscheinlich abgedeckt“ ist.

Führen Sie eine Schema-Validierung für die Argumente der Tools durch. Ein falsch eingegebener Anfragen-ID sollte dazu führen, dass der Toolaufruf fehlschlägt, bevor eine falsche Untersuchungsergebnisbeschreibung entsteht.

Trennen Sie Lesewerkzeuge von Schreibwerkzeugen. Triage-Agenten arbeiten standardmäßig im Lesemodus; Schreibvorgänge zur Abrechnung erfordern die Genehmigungsstufe sowie einen Idempotenzschlüssel.

Weisen Sie Fehlern in Application Insights konkrete Maßnahmen zu: Ein Anstieg der Timeout-Zeiten bei Betrugsprüfwerkzeugen sollte standardmäßig den Verantwortlichen für die SIU-Integration und nicht das LLM-Plattformteam betreffen.

Bewahren Sie synthetische Anträge in einem Testdatensatz auf, der auch Randfälle umfasst: abgelaufene Policen, grenzwertige Betrugsquoten sowie Mehrfahrzeug-Unfälle, die die Routenvergabe belasten.

Beim Vorstellen an Führungskräfte sollten Sie den Trace-Waterfall für einen Antrag zeigen. Der Schwerpunkt liegt auf Orchestrierung und Kontrollmechanismen, nicht auf Markennamen der Modelle.

Spezialistische Anfragen sollten das Erfinden von Policenbestimmungen verbieten. Wenn das Abdeckungstool leere Ergebnisse liefert, muss der Spezialist die Angelegenheit weiterleiten – anstatt zu vermuten, dass der Antrag „wahrscheinlich abgedeckt“ ist.

Führen Sie eine Schema-Validierung für die Tool-Argumente ein. Ein falsch eingegebener Claim-ID sollte dazu führen, dass der Tool-Aufruf fehlschlägt, bevor daraus eine falsche Untersuchungsnarrative entsteht.

Trennen Sie Lesetools von Schreibtools. Triage-Agenten arbeiten standardmäßig nur im Lesemodus; Schreibvorgänge erfordern eine Genehmigung sowie einen Idempotenzschlüssel.

Verknüpfen Sie Fehler aus Application Insights mit konkreten Maßnahmen: Ein Anstieg der Timeout-Zeiten bei Betrugstools sollte standardmäßig den Verantwortlichen für die SIU-Integration melden, nicht das LLM-Plattformteam.

Bewahren Sie synthetische Claims in einem Testdatensatz auf, der auch Randfälle umfasst: abgelaufene Policen, grenzwertige Betrugsquoten sowie Mehrfahrzeug-Unfälle, die die Routenplanung belasten.

Beim Vorstellen an Führungskräfte sollten Sie die Trace-Wasserfall-Ansicht für einen Claim zeigen. Der Fokus liegt auf der Orchestrierung und den Kontrollmechanismen, nicht auf den Markennamen der Modelle.

Spezialistische Anweisungen sollten das Erfinden von Versicherungsbedingungen verbieten. Wenn das Abdeckungstool leer zurückgibt, muss der Spezialist die Angelegenheit weiterleiten – anstatt zu vermuten, dass etwas „wahrscheinlich abgedeckt“ ist.

Führen Sie eine Schema-Validierung für die Tool-Argumente durch. Ein falsch eingegebener Anspruchsinhalt sollte dazu führen, dass der Toolaufruf fehlschlägt, bevor eine falsche Untersuchungsnarrative entsteht.

Trennen Sie Lesetools von Schreibtools. Triage-Mitarbeiter arbeiten standardmäßig nur im Lesemodus; Schreibvorgänge für Abrechnungen erfordern eine Genehmigungsstufe sowie einen Idempotenzschlüssel.

Ordnen Sie Fehlfälle von Application Insights konkreten Maßnahmen zu: Ein Anstieg der Timeout-Zeiten beim Betrugserkennungstool sollte standardmäßig den Verantwortlichen für die SIU-Integration informieren, nicht das LLM-Plattformteam.

Bewahren Sie synthetische Ansprüche in einem Testdatensatz auf, der auch Randfälle umfasst: abgelaufene Versicherungsbedingungen, grenzwertige Betrugsquoten sowie Mehrfahrzeug-Unfälle, die die Routenplanung belasten.

Beim Vorstellen an Führungskräfte sollte die Trace-Wasserfall-Ansicht für eine einzelne Schadensmeldung gezeigt werden. Es geht um Orchestrierung und Kontrollmechanismen, nicht um Markennamen von Modellen.

Spezialisten sollten dazu angehalten werden, keine eigenen Policenbedingungen zu erfinden. Wenn das Abdeckungstool leere Ergebnisse liefert, muss der Spezialist die Angelegenheit weiterleiten – anstatt zu vermuten, dass die Schadensmeldung wahrscheinlich abgedeckt ist.

Führen Sie eine Schema-Validierung für die Argumente der Tools durch. Eine falsch eingegebene Schadensmeldungs-ID sollte dazu führen, dass der Toolaufruf fehlschlägt, bevor eine falsche Untersuchungsnarrative entsteht.

Trennen Sie Lesetools von Schreibtools. Triage-Mitarbeiter arbeiten standardmäßig nur im Lesemodus; Schreibvorgänge zur Abwicklung erfordern eine Genehmigungsstufe sowie einen Idempotenzschlüssel.

Ordnen Sie Fehler aus Application Insights konkreten Maßnahmen zu: Ein Anstieg der Timeout-Fälle bei den Betrugsdetektortools sollte standardmäßig den Verantwortlichen für die SIU-Integration melden, nicht das LLM-Plattformteam.

Halten Sie synthetische Anträge in einem Paket mit Randfällen bereit: abgelaufene Policen, grenzwertige Betrugsbewertungen sowie Unfälle mit mehreren Fahrzeugen, die die Routenplanung belasten.

Beim Vorstellen an Führungskräfte zeigen Sie den Trace-Wasserfall für einen Antrag. Es geht um Orchestrierung und Kontrollmechanismen, nicht um Markennamen von Modellen.

← Alle Artikel Brief senden