# LangDoc Connector

Der LangDoc Connector ermöglicht die Integration der LangDoc API in das PowerOn Gateway System. LangDoc ist eine OpenAI-kompatible API, die verschiedene KI-Modelle bereitstellt.

## Konfiguration

### Umgebungsvariablen

Die folgenden Konfigurationsparameter müssen in den entsprechenden Umgebungsdateien gesetzt werden:

```ini
# LangDoc configuration
Connector_AiLangdoc_API_URL = https://api.langdock.com/v1/chat/completions
Connector_AiLangdoc_API_SECRET = YOUR_LANGDOC_API_KEY_HERE
Connector_AiLangdoc_MODEL_NAME = gpt-4o
Connector_AiLangdoc_TEMPERATURE = 0.2
```

### API-Schlüssel erhalten

1. Melden Sie sich bei Ihrem LangDoc-Konto an
2. Navigieren Sie zu den API-Einstellungen
3. Generieren Sie einen neuen API-Schlüssel
4. Benennen Sie den Schlüssel entsprechend und speichern Sie ihn sicher

## Verfügbare Funktionen

### 1. Textgenerierung (`callAiBasic`)

```python
from modules.connectors.connectorAiLangdoc import AiLangdoc

# Connector initialisieren
langdoc = AiLangdoc()

# Nachrichten für die API vorbereiten
messages = [
    {"role": "user", "content": "Erkläre mir die Grundlagen von Machine Learning"}
]

# API aufrufen
response = await langdoc.callAiBasic(messages)
print(response)
```

**Parameter:**
- `messages`: Liste von Nachrichten im OpenAI-Format (role, content)
- `temperature`: Temperatur für die Antwortgenerierung (0.0-1.0, optional)
- `maxTokens`: Maximale Anzahl der Tokens in der Antwort (optional)

### 2. Bildanalyse (`callAiImage`)

```python
# Bildanalyse mit LangDoc Vision
prompt = "Beschreibe was du auf diesem Bild siehst"
image_path = "/path/to/image.jpg"

response = await langdoc.callAiImage(prompt, image_path)
print(response)
```

**Parameter:**
- `prompt`: Prompt für die Bildanalyse
- `imageData`: Dateipfad (str) oder Bilddaten (bytes)
- `mimeType`: MIME-Typ des Bildes (optional)

### 3. Verfügbare Modelle auflisten (`listModels`)

```python
# Alle verfügbaren Modelle auflisten
models = await langdoc.listModels()
for model in models:
    print(f"Model: {model['id']}")
```

### 4. Modellinformationen abrufen (`getModelInfo`)

```python
# Informationen zu einem spezifischen Modell
model_info = await langdoc.getModelInfo("gpt-4o")
print(f"Model Details: {model_info}")
```

### 5. Verbindung testen (`_testConnection`)

```python
# Verbindung zur LangDoc API testen
is_connected = await langdoc._testConnection()
if is_connected:
    print("Verbindung erfolgreich!")
else:
    print("Verbindung fehlgeschlagen!")
```

## Unterstützte Modelle

LangDoc unterstützt verschiedene KI-Modelle, darunter:

- **GPT-4o**: Neuestes OpenAI-Modell mit Vision-Fähigkeiten
- **GPT-4**: Hochleistungsmodell für komplexe Aufgaben
- **GPT-3.5-turbo**: Schnelles und kosteneffizientes Modell
- **Claude 3.5 Sonnet**: Anthropic-Modell über LangDoc
- **Gemini Pro**: Google-Modell über LangDoc

## Verwendung in Workflows

Der LangDoc Connector kann in PowerOn Workflows verwendet werden:

```python
# Beispiel für Workflow-Integration
async def processWithLangDoc(workflow_data):
    langdoc = AiLangdoc()
    
    # Textverarbeitung
    messages = [
        {"role": "system", "content": "Du bist ein hilfreicher Assistent."},
        {"role": "user", "content": workflow_data.get("user_input")}
    ]
    
    result = await langdoc.callAiBasic(messages)
    return {"ai_response": result}
```

## Fehlerbehandlung

Der Connector behandelt verschiedene Fehlertypen:

- **401 Unauthorized**: Ungültiger API-Schlüssel
- **429 Too Many Requests**: Rate Limit überschritten
- **400 Bad Request**: Ungültige Anfrage
- **500 Internal Server Error**: Server-seitige Fehler

## Sicherheitshinweise

1. **API-Schlüssel sicher aufbewahren**: Verwenden Sie die Verschlüsselungsfunktionen des Systems
2. **Rate Limits beachten**: LangDoc hat eigene Rate Limits
3. **Datenvalidierung**: Validiere alle Eingaben vor dem API-Aufruf
4. **Logging**: Alle API-Aufrufe werden geloggt für Debugging und Monitoring

## Beispiel-Anwendungsfälle

### 1. Dokumentenanalyse
```python
# Analyse von Dokumenten
messages = [
    {"role": "user", "content": f"Analysiere dieses Dokument: {document_text}"}
]
analysis = await langdoc.callAiBasic(messages)
```

### 2. Code-Generierung
```python
# Code-Generierung
messages = [
    {"role": "user", "content": "Schreibe eine Python-Funktion für die Berechnung von Fibonacci-Zahlen"}
]
code = await langdoc.callAiBasic(messages)
```

### 3. Übersetzung
```python
# Textübersetzung
messages = [
    {"role": "user", "content": f"Übersetze folgenden Text ins Englische: {german_text}"}
]
translation = await langdoc.callAiBasic(messages)
```

### 4. Zusammenfassung
```python
# Textzusammenfassung
messages = [
    {"role": "user", "content": f"Fasse folgenden Text zusammen: {long_text}"}
]
summary = await langdoc.callAiBasic(messages)
```

## Support und Dokumentation

- **LangDoc API Dokumentation**: https://docs.langdock.com/
- **LangDoc Website**: https://www.langdock.com/
- **PowerOn Gateway Dokumentation**: Siehe README.md im Hauptverzeichnis