> ## Documentation Index
> Fetch the complete documentation index at: https://docs.langdock.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Agenten-Migrations-Anleitung

> Wie man Agenten zwischen Langdock Workspaces mit der Agents API migriert

Diese Anleitung erklärt, wie man Agenten (Assistenten) von einem Langdock Workspace in einen anderen migriert, indem man die Agents API verwendet. Dies ist nützlich, wenn du Agenten-Konfigurationen über verschiedene Workspaces hinweg replizieren, Agenten während einer organisatorischen Umstrukturierung verschieben oder Backup-Kopien deiner Agenten erstellen möchtest.

## Überblick

Der Migrationsprozess umfasst zwei Hauptschritte:

1. **Export**: Abrufen der Agenten-Konfiguration aus dem Quell-Workspace mit der [Agent Get API](/de/developer/agents-api/agent-get)
2. **Import**: Erstellen eines neuen Agenten im Ziel-Workspace mit der [Agent Create API](/de/developer/agents-api/agent-create)

## Voraussetzungen

Bevor du beginnst, stelle sicher, dass du folgendes hast:

1. **`Zwei API-Schlüssel mit AGENT_API Berechtigung`**:
   * Einen API-Schlüssel für den **Quell-Workspace** (wo der Agent aktuell existiert)
   * Einen API-Schlüssel für den **Ziel-Workspace** (wohin du den Agenten migrieren möchtest)
2. **Zugriff auf den Agenten**: Dein Quell-Workspace API-Schlüssel muss Zugriff auf den Agenten haben, den du migrieren möchtest
3. **Übereinstimmende Ressourcen im Ziel-Workspace** (falls zutreffend):
   * Das Modell muss nach der Migration manuell in der Langdock-Oberfläche angepasst werden
   * Wenn der Agent benutzerdefinierte Aktionen verwendet, müssen diese Integrationen im Ziel-Workspace aktiviert sein
   * Anhänge müssen separat hochgeladen werden (sie werden nicht automatisch übertragen)

## Schritt 1: Agent aus dem Quell-Workspace exportieren

Verwende die **Agent Get API**, um die vollständige Konfiguration deines Agenten abzurufen:

```javascript theme={null}
const axios = require("axios");

async function getAgentFromSource(agentId, sourceApiKey) {
  const response = await axios.get(
    "https://api.langdock.com/agent/v1/get",
    {
      params: {
        agentId: agentId
      },
      headers: {
        Authorization: `Bearer ${sourceApiKey}`
      }
    }
  );

  return response.data.agent;
}
```

### Die Antwort verstehen

Die Get API gibt die vollständige Agenten-Konfiguration zurück, einschließlich:

* `name`, `description`, `instruction` - Die Identität und der System-Prompt des Agenten

* `emojiIcon` - Das Emoji-Icon, das für den Agenten angezeigt wird

* `temperature` - Kreativitätseinstellung (0-1)

* `conversationStarters` - Vorgeschlagene Prompts für Benutzer

* `inputType` - Entweder "PROMPT" oder "STRUCTURED"

* `inputFields` - Formularfeld-Definitionen (für STRUCTURED Eingabetyp)

* `webSearchEnabled`, `imageGenerationEnabled`, `canvasEnabled` - Fähigkeits-Flags

* `actions` - Benutzerdefinierte Integrations-Aktionen

* `attachments` - UUIDs der angehängten Dateien

## Schritt 2: Konfiguration transformieren

Die Get API-Antwort verwendet etwas andere Feldnamen als die Create API erwartet. Du musst die Felder mappen:

```javascript theme={null}
function transformForCreate(sourceAgent) {
  return {
    // Grundinformationen
    name: sourceAgent.name,
    description: sourceAgent.description || undefined,
    emoji: sourceAgent.emojiIcon || undefined,
    instruction: sourceAgent.instruction || undefined,
    
    // Einstellungen
    creativity: sourceAgent.temperature,
    inputType: sourceAgent.inputType,
    conversationStarters: sourceAgent.conversationStarters || [],
    
    // Fähigkeiten
    webSearch: sourceAgent.webSearchEnabled,
    imageGeneration: sourceAgent.imageGenerationEnabled,
    canvas: sourceAgent.canvasEnabled,
    
    // Eingabefelder (für STRUCTURED Eingabetyp)
    inputFields: sourceAgent.inputFields || [],
    
    // Hinweis: actions und attachments erfordern spezielle Behandlung (siehe unten)
  };
}
```

### Feld-Mapping Referenz

| Get API Antwortfeld      | Create API Anforderungsfeld |
| ------------------------ | --------------------------- |
| `name`                   | `name`                      |
| `description`            | `description`               |
| `emojiIcon`              | `emoji`                     |
| `instruction`            | `instruction`               |
| `temperature`            | `creativity`                |
| `inputType`              | `inputType`                 |
| `conversationStarters`   | `conversationStarters`      |
| `webSearchEnabled`       | `webSearch`                 |
| `imageGenerationEnabled` | `imageGeneration`           |
| `canvasEnabled`          | `canvas`                    |
| `inputFields`            | `inputFields`               |
| `actions`                | `actions`                   |
| `attachments`            | `attachments`               |

## Schritt 3: Agent im Ziel-Workspace erstellen

Verwende die **Agent Create API**, um den Agenten im Ziel-Workspace zu erstellen:

```javascript theme={null}
async function createAgentInTarget(agentConfig, targetApiKey) {
  const response = await axios.post(
    "https://api.langdock.com/agent/v1/create",
    agentConfig,
    {
      headers: {
        Authorization: `Bearer ${targetApiKey}`,
        "Content-Type": "application/json"
      }
    }
  );

  return response.data.agent;
}
```

## Vollständiges Migrations-Skript

Hier ist ein vollständiges Skript, das alle Schritte kombiniert:

```javascript theme={null}
const axios = require("axios");

// Konfiguration
const SOURCE_API_KEY = "dein-quell-workspace-api-schluessel";
const TARGET_API_KEY = "dein-ziel-workspace-api-schluessel";
const AGENT_ID_TO_MIGRATE = "550e8400-e29b-41d4-a716-446655440000";

async function migrateAgent() {
  try {
    // Schritt 1: Agent aus Quell-Workspace abrufen
    console.log("Agent aus Quell-Workspace abrufen...");
    const getResponse = await axios.get(
      "https://api.langdock.com/agent/v1/get",
      {
        params: { agentId: AGENT_ID_TO_MIGRATE },
        headers: { Authorization: `Bearer ${SOURCE_API_KEY}` }
      }
    );
    
    const sourceAgent = getResponse.data.assistant;
    console.log(`Agent gefunden: "${sourceAgent.name}"`);

    // Schritt 2: Konfiguration für Create API transformieren
    const createConfig = {
      name: sourceAgent.name,
      description: sourceAgent.description || undefined,
      emoji: sourceAgent.emojiIcon || undefined,
      instruction: sourceAgent.instruction || undefined,
      creativity: sourceAgent.temperature,
      inputType: sourceAgent.inputType,
      conversationStarters: sourceAgent.conversationStarters || [],
      webSearch: sourceAgent.webSearchEnabled,
      imageGeneration: sourceAgent.imageGenerationEnabled,
      canvas: sourceAgent.canvasEnabled,
      inputFields: sourceAgent.inputFields || [],
      // Hinweis: actions und attachments ausgeschlossen - siehe "Spezialfälle behandeln"
    };

    // Undefined-Werte entfernen
    Object.keys(createConfig).forEach(key => {
      if (createConfig[key] === undefined) {
        delete createConfig[key];
      }
    });

    // Schritt 3: Agent im Ziel-Workspace erstellen
    console.log("Agent im Ziel-Workspace erstellen...");
    const createResponse = await axios.post(
      "https://api.langdock.com/agent/v1/create",
      createConfig,
      {
        headers: {
          Authorization: `Bearer ${TARGET_API_KEY}`,
          "Content-Type": "application/json"
        }
      }
    );

    const newAgent = createResponse.data.assistant;
    console.log(`Migration erfolgreich!`);
    console.log(`Neue Agenten-ID: ${newAgent.id}`);
    console.log(`Agenten-Name: ${newAgent.name}`);
    
    return newAgent;

  } catch (error) {
    if (error.response) {
      console.error(`Fehler ${error.response.status}: ${JSON.stringify(error.response.data)}`);
    } else {
      console.error("Fehler:", error.message);
    }
    throw error;
  }
}

migrateAgent();
```

## Spezialfälle behandeln

### Aktionen (Benutzerdefinierte Integrationen)

Aktionen referenzieren Integrationen, die im Ziel-Workspace aktiviert sein müssen. Aktions-UUIDs sind spezifisch für das Integrations-Setup jedes Workspaces.

<Warning>
  Schließe Aktionen von der initialen Migration aus und konfiguriere sie manuell im Ziel-Workspace, nachdem der Agent erstellt wurde.
</Warning>

### Anhänge

Anhangs-UUIDs referenzieren Dateien, die im Quell-Workspace gespeichert sind. Diese Dateien werden nicht automatisch übertragen.

**Um Anhänge zu migrieren**:

1. Lade die Dateien aus dem Quell-Workspace herunter
2. Lade sie erneut in den Ziel-Workspace mit der [Upload Attachment API](/de/developer/agents-api/upload-attachments) hoch
3. Aktualisiere den Agenten mit den neuen Anhangs-UUIDs

### OAuth-Verbindungen

<Warning>
  Vorausgewählte OAuth-Verbindungen werden **nicht über die API unterstützt**. Benutzer müssen OAuth-Verbindungen nach der Migration über die Langdock-Oberfläche konfigurieren.
</Warning>

## Mehrere Agenten migrieren

Um mehrere Agenten zu migrieren, durchlaufe einfach eine Liste von Agenten-IDs:

```javascript theme={null}
const AGENT_IDS = [
  "agent-uuid-1",
  "agent-uuid-2",
  "agent-uuid-3"
];

async function migrateMultipleAgents() {
  const results = [];
  
  for (const agentId of AGENT_IDS) {
    try {
      console.log(`\nMigriere Agent: ${agentId}`);
      const newAgent = await migrateAgent(agentId);
      results.push({ 
        sourceId: agentId, 
        targetId: newAgent.id, 
        status: "erfolgreich" 
      });
    } catch (error) {
      results.push({ 
        sourceId: agentId, 
        status: "fehlgeschlagen", 
        error: error.message 
      });
    }
  }
  
  console.log("\n=== Migrations-Zusammenfassung ===");
  console.table(results);
}
```

## Checkliste nach der Migration

Überprüfe nach der Migration eines Agenten folgendes im Ziel-Workspace:

* Agent erscheint in der Agenten-Liste mit korrektem Namen und Emoji
* Beschreibung und Anweisungen wurden korrekt übertragen
* Gesprächsstarter sind vorhanden
* Fähigkeiten (Websuche, Bildgenerierung, etc.) sind korrekt aktiviert
* Eingabefelder sind richtig konfiguriert (für STRUCTURED Eingabetyp)
* OAuth-Verbindungen manuell über die Oberfläche konfigurieren
* Erforderliche Dateien erneut hochladen und anhängen
* Benutzerdefinierte Aktionen/Integrationen bei Bedarf konfigurieren
* Agent testen, indem eine Nachricht gesendet wird

## Einschränkungen

<Info>
  Behalte diese Einschränkungen bei der Planung deiner Migration im Hinterkopf:
</Info>

1. **Anhänge werden nicht übertragen** - Dateien müssen im Ziel-Workspace erneut hochgeladen werden
2. **Aktionen müssen möglicherweise neu konfiguriert werden** - Integrations-Aktions-UUIDs sind workspace-spezifisch
3. **OAuth-Verbindungen erfordern manuelle Einrichtung** - Können nicht über die API konfiguriert werden
4. **Modelle erfordern manuelle Anpassung** - Der Agent verwendet das Standard-Modell des Workspaces; passe es nach der Migration manuell in der Oberfläche an
5. **Gesprächsverlauf wird nicht migriert** - Nur die Agenten-Konfiguration wird übertragen

<Info>
  Langdock blockiert bewusst Browser-basierte Anfragen, um deinen API-Schlüssel zu schützen und die Sicherheit deiner Anwendungen zu gewährleisten. Weitere Informationen findest du in unserem Guide zu [Best Practices für API-Schlüssel](/de/admin/ai-adoption-and-rollout/best-practices/api-key-best-practices).
</Info>
