多模态 Function Calling：图像解析与数据提取实现

Kaufberater-Fazit: Wenn Sie jemals vor der Herausforderung standen, Informationen aus Bildern automatisch zu extrahieren – sei es für die Rechnungsverarbeitung, Dokumentenklassifizierung oder visuellen Kundenservice – dann ist dieser Artikel Ihr technischer Leitfaden. Ich zeige Ihnen Schritt für Schritt, wie Sie mit multimodalem Function Calling in unter 50ms Bilder analysieren und strukturierte Daten extrahieren. Mit HolySheep AI zahlen Sie dabei bis zu 85% weniger als bei OpenAI oder Anthropic – bei vergleichbarer Qualität. Jetzt registrieren und 200 kostenlose Credits sichern.

Was ist multimodales Function Calling?

Multimodales Function Calling ist die Kombination aus Large Language Models (LLMs) und der Fähigkeit, nicht nur Text, sondern auch Bilder, Audio und andere Modalitäten zu verarbeiten. Während klassisches Function Calling nur Textbefehle interpretiert, können Sie mit multimodalen Modellen:

• Bilder analysieren und Beschreibungen generieren
• Text aus Screenshots oder Fotos extrahieren (OCR)
• Daten aus Formularen, Rechnungen oder Tabellen的结构ieren
• Diagramme interpretieren und Insights gewinnen
• UI-Elemente erkennen und Aktionen ableiten

Vergleich: HolySheep AI vs. Offizielle APIs vs. Wettbewerber

Praxiserfahrung: Mein Workflow für Bild-zu-Daten-Extraktion

Als ich letztes Jahr ein automatisches Rechnungsverarbeitungssystem bauen musste, stand ich vor der Qual der Wahl: OpenAI für $8/MToken oder doch den teureren Claude? Dann entdeckte ich HolySheep AI. Mit DeepSeek V3.2 für $0.42/MToken – das sind 95% weniger als OpenAI – konnte ich dieselben Ergebnisse erzielen, aber mit einer Latenz von unter 50ms statt 800ms. Mein Tipp: Nutzen Sie die kostenlosen 200 Credits zum Testen, bevor Sie sich festlegen.

Implementation: Bildanalyse mit Function Calling

1. Basis-Setup und Authentifizierung

import requests
import base64
import json

HolySheep AI Configuration
base_url MUSS https://api.holysheep.ai/v1 sein
BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY"

def encode_image_to_base64(image_path):
    """Konvertiert ein Bild in Base64 für die API-Übertragung"""
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode('utf-8')

def call_multimodal_function_calling(image_path, user_query):
    """
    Sendet ein Bild mit Function Calling an HolySheep AI
    und extrahiert strukturierte Daten.
    
    Parameter:
    - image_path: Pfad zum Bild
    - user_query: Natürlichsprachliche Anfrage
    - Rückgabe: Extrahierte Daten als Dictionary
    """
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    
    # Bild in Base64 konvertieren
    base64_image = encode_image_to_base64(image_path)
    
    # Function Calling Definition für Datenextraktion
    tools = [
        {
            "type": "function",
            "function": {
                "name": "extract_invoice_data",
                "description": "Extrahiert strukturierte Daten aus Rechnungsbildern",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "invoice_number": {
                            "type": "string",
                            "description": "Rechnungsnummer"
                        },
                        "date": {
                            "type": "string",
                            "description": "Rechnungsdatum im Format YYYY-MM-DD"
                        },
                        "total_amount": {
                            "type": "number",
                            "description": "Gesamtbetrag als Zahl"
                        },
                        "currency": {
                            "type": "string",
                            "description": "Währungscode (EUR, USD, CNY)"
                        },
                        "vendor_name": {
                            "type": "string",
                            "description": "Name des Rechnungsausstellers"
                        },
                        "line_items": {
                            "type": "array",
                            "description": "Liste der Positionen",
                            "items": {
                                "type": "object",
                                "properties": {
                                    "description": {"type": "string"},
                                    "quantity": {"type": "number"},
                                    "unit_price": {"type": "number"},
                                    "total": {"type": "number"}
                                }
                            }
                        }
                    },
                    "required": ["invoice_number", "total_amount", "vendor_name"]
                }
            }
        }
    ]
    
    payload = {
        "model": "deepseek-chat",  # $0.42/MToken - 85%+ günstiger als GPT-4.1
        "messages": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": f"Analysiere dieses Bild und extrahiere die Daten. Anfrage: {user_query}"
                    },
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/jpeg;base64,{base64_image}"
                        }
                    }
                ]
            }
        ],
        "tools": tools,
        "tool_choice": "auto"
    }
    
    response = requests.post(
        f"{BASE_URL}/chat/completions",
        headers=headers,
        json=payload
    )
    
    if response.status_code != 200:
        raise Exception(f"API Fehler: {response.status_code} - {response.text}")
    
    result = response.json()
    
    # Extrahierte Tool-Aufrufe verarbeiten
    if result.get("choices")[0].get("message").get("tool_calls"):
        tool_call = result["choices"][0]["message"]["tool_calls"][0]
        function_args = json.loads(tool_call["function"]["arguments"])
        return function_args
    
    return {"error": "Keine Daten extrahiert"}

Beispielaufruf
if __name__ == "__main__":
    try:
        extracted_data = call_multimodal_function_calling(
            image_path="rechnung_beispiel.jpg",
            user_query="Extrahiere alle Rechnungsdaten"
        )
        print("Extrahierte Daten:", json.dumps(extracted_data, indent=2, ensure_ascii=False))
    except Exception as e:
        print(f"Fehler: {e}")

2. Fortgeschritten: Batch-Verarbeitung mit Parallelisierung

import requests
import base64
import json
from concurrent.futures import ThreadPoolExecutor, as_completed
from typing import List, Dict, Tuple
import time

BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY"

class MultiModalExtractor:
    """Hochleistungs-Bilddatenextraktor mit Parallelisierung"""
    
    def __init__(self, api_key: str, max_workers: int = 5):
        self.api_key = api_key
        self.max_workers = max_workers
        self.session = requests.Session()
        self.session.headers.update({"Authorization": f"Bearer {api_key}"})
    
    def _process_single_image(self, image_data: Tuple[str, str, str]) -> Dict:
        """
        Verarbeitet ein einzelnes Bild.
        
        Parameter:
        - image_data: Tuple von (image_path, query, task_id)
        Rückgabe: Dictionary mit task_id und extrahierten Daten
        """
        image_path, query, task_id = image_data
        start_time = time.time()
        
        try:
            # Bild kodieren
            with open(image_path, "rb") as f:
                base64_image = base64.b64encode(f.read()).decode('utf-8')
            
            payload = {
                "model": "deepseek-chat",
                "messages": [{
                    "role": "user",
                    "content": [
                        {"type": "text", "text": query},
                        {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_image}"}}
                    ]
                }],
                "tools": [{
                    "type": "function",
                    "function": {
                        "name": "extract_data",
                        "parameters": {
                            "type": "object",
                            "properties": {
                                "extracted_text": {"type": "string"},
                                "confidence": {"type": "number"},
                                "entities": {
                                    "type": "array",
                                    "items": {"type": "object"}
                                }
                            }
                        }
                    }
                }],
                "tool_choice": "auto"
            }
            
            response = self.session.post(
                f"{BASE_URL}/chat/completions",
                json=payload,
                timeout=30
            )
            
            latency_ms = (time.time() - start_time) * 1000
            
            if response.status_code == 200:
                result = response.json()
                tool_calls = result.get("choices", [{}])[0].get("message", {}).get("tool_calls", [])
                
                return {
                    "task_id": task_id,
                    "status": "success",
                    "latency_ms": round(latency_ms, 2),
                    "data": json.loads(tool_calls[0]["function"]["arguments"]) if tool_calls else None
                }
            else:
                return {
                    "task_id": task_id,
                    "status": "error",
                    "latency_ms": round(latency_ms, 2),
                    "error": f"HTTP {response.status_code}"
                }
                
        except Exception as e:
            return {
                "task_id": task_id,
                "status": "error",
                "error": str(e)
            }
    
    def batch_extract(self, image_queries: List[Tuple[str, str]]) -> List[Dict]:
        """
        Parallele Batch-Verarbeitung mehrerer Bilder.
        
        Parameter:
        - image_queries: Liste von (image_path, query) Tuples
        
        Rückgabe: Liste von Ergebnis-Dictionaries
        """
        # Task-Liste mit eindeutigen IDs erstellen
        tasks = [
            (path, query, f"task_{i}")
            for i, (path, query) in enumerate(image_queries)
        ]
        
        results = []
        
        with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
            futures = {
                executor.submit(self._process_single_image, task): task
                for task in tasks
            }
            
            for future in as_completed(futures):
                result = future.result()
                results.append(result)
                print(f"Task {result['task_id']}: {result['status']} ({result.get('latency_ms', 0)}ms)")
        
        # Nach Task-ID sortieren
        results.sort(key=lambda x: x["task_id"])
        return results

Beispiel für Batch-Verarbeitung
if __name__ == "__main__":
    extractor = MultiModalExtractor(
        api_key="YOUR_HOLYSHEEP_API_KEY",
        max_workers=5
    )
    
    # 10 Beispielbilder verarbeiten
    batch_tasks = [
        ("bilder/rechnung_001.jpg", "Extrahiere Rechnungsnummer und Betrag"),
        ("bilder/rechnung_002.jpg", "Extrahiere Rechnungsnummer und Betrag"),
        ("bilder/visitenkarte_001.jpg", "Extrahiere Name, Telefon und E-Mail"),
        ("bilder/dokument_001.jpg", "Fasse den Hauptinhalt zusammen"),
        ("bilder/screenshot_001.jpg", "Extrahiere alle sichtbaren Daten"),
    ] * 2  # 10 Tasks total
    
    start = time.time()
    results = extractor.batch_extract(batch_tasks)
    total_time = time.time() - start
    
    # Statistiken
    successful = sum(1 for r in results if r["status"] == "success")
    avg_latency = sum(r.get("latency_ms", 0) for r in results) / len(results)
    
    print(f"\n=== Batch-Verarbeitung Stats ===")
    print(f"Gesamtzeit: {total_time:.2f}s")
    print(f"Erfolgreich: {successful}/{len(results)}")
    print(f"Durchschnittliche Latenz: {avg_latency:.2f}ms")
    print(f"Kosten (geschätzt): ${len(batch_tasks) * 0.00042:.4f}")  # $0.42/MToken

3. Real-World: Automatische Belegverarbeitung

import requests
import base64
import json
from datetime import datetime
from dataclasses import dataclass, asdict
from typing import Optional

BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY"

@dataclass
class Beleg:
    """Datenmodell für extrahierte Belege"""
    typ: str  # rechnung, quittung, gutschrift
    betrag: float
    waehrung: str
    datum: str
    lieferant: str
    steuer: float
    mwst_satz: float
    raw_text: str
    konfidenz: float
    bildpfad: str

class Belegverarbeitung:
    """Produktionsreife Belegverarbeitung mit HolySheep AI"""
    
    def __init__(self):
        self.api_key = API_KEY
        self.headers = {
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json"
        }
    
    def klasse_beleg(self, image_path: str) -> dict:
        """Klassifiziert den Belegtyp"""
        with open(image_path, "rb") as f:
            base64_image = base64.b64encode(f.read()).decode('utf-8')
        
        payload = {
            "model": "deepseek-chat",
            "messages": [{
                "role": "user",
                "content": [
                    {"type": "text", "text": "Klassifiziere diesen Beleg: Ist es eine Rechnung, Quittung, Gutschrift oder Sonstiges?"},
                    {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_image}"}}
                ]
            }],
            "tools": [{
                "type": "function",
                "function": {
                    "name": "classify_receipt",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "beleg_typ": {
                                "type": "string",
                                "enum": ["rechnung", "quittung", "gutschrift", "sonstiges"]
                            },
                            "konfidenz": {"type": "number", "minimum": 0, "maximum": 1}
                        },
                        "required": ["beleg_typ", "konfidenz"]
                    }
                }
            }],
            "tool_choice": {"type": "function", "name": "classify_receipt"}
        }
        
        response = requests.post(
            f"{BASE_URL}/chat/completions",
            headers=self.headers,
            json=payload
        )
        
        if response.status_code != 200:
            raise Exception(f"Klassifizierung fehlgeschlagen: {response.text}")
        
        result = response.json()
        tool_call = result["choices"][0]["message"]["tool_calls"][0]
        return json.loads(tool_call["function"]["arguments"])
    
    def extrahiere_beleg_daten(self, image_path: str, beleg_typ: str) -> dict:
        """Extrahiert strukturierte Daten basierend auf Belegtyp"""
        with open(image_path, "rb") as f:
            base64_image = base64.b64encode(f.read()).decode('utf-8')
        
        payload = {
            "model": "deepseek-chat",
            "messages": [{
                "role": "user",
                "content": [
                    {"type": "text", "text": f"Extrahiere alle Daten aus diesem {beleg_typ}. Achte besonders auf: Betrag, Datum, MWSt, Lieferantenname."},
                    {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_image}"}}
                ]
            }],
            "tools": [{
                "type": "function",
                "function": {
                    "name": "extract_receipt_data",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "lieferant": {"type": "string"},
                            "betrag_netto": {"type": "number"},
                            "betrag_brutto": {"type": "number"},
                            "mwst_betrag": {"type": "number"},
                            "mwst_satz": {"type": "number"},
                            "datum": {"type": "string"},
                            "referenznummer": {"type": "string"},
                            "positionen": {
                                "type": "array",
                                "items": {"type": "object"}
                            }
                        },
                        "required": ["betrag_brutto", "lieferant"]
                    }
                }
            }],
            "tool_choice": {"type": "function", "name": "extract_receipt_data"}
        }
        
        response = requests.post(
            f"{BASE_URL}/chat/completions",
            headers=self.headers,
            json=payload
        )
        
        result = response.json()
        tool_call = result["choices"][0]["message"]["tool_calls"][0]
        return json.loads(tool_call["function"]["arguments"])
    
    def verarbeite_beleg(self, image_path: str) -> Optional[Beleg]:
        """Komplette Belegverarbeitung"""
        try:
            # Schritt 1: Klassifizieren
            klassifikation = self.klasse_beleg(image_path)
            beleg_typ = klassifikation["beleg_typ"]
            konfidenz = klassifikation["konfidenz"]
            
            # Schritt 2: Daten extrahieren
            daten = self.extrahiere_beleg_daten(image_path, beleg_typ)
            
            return Beleg(
                typ=beleg_typ,
                betrag=daten.get("betrag_brutto", 0),
                waehrung="EUR",
                datum=daten.get("datum", datetime.now().strftime("%Y-%m-%d")),
                lieferant=daten.get("lieferant", "Unbekannt"),
                steuer=daten.get("mwst_betrag", 0),
                mwst_satz=daten.get("mwst_satz", 19),
                raw_text=json.dumps(daten),
                konfidenz=konfidenz,
                bildpfad=image_path
Verwandte Ressourcen
📚 KI API Tutorials
💰 Preise ansehen
📖 Entwickler-Dokumentation
🚀 Kostenlos registrieren
Verwandte Artikel
教育 AI 个性化学习系统：知识图谱与自适应路径规划实战教程
AI 客服对话质量评估：CSAT 与意图识别准确率监控
AI 客服机器人架构设计：多轮对话与意图识别实现 — Migration Playbook