Zum Hauptinhalt springen

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.

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
  2. Import: Erstellen eines neuen Agenten im Ziel-Workspace mit der Agent Create API

​
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: 
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, codeInterpreterEnabled, 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: 
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,
    dataAnalyst: sourceAgent.codeInterpreterEnabled,
    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 AntwortfeldCreate API Anforderungsfeld
namename
descriptiondescription
emojiIconemoji
instructioninstruction
temperaturecreativity
inputTypeinputType
conversationStartersconversationStarters
webSearchEnabledwebSearch
imageGenerationEnabledimageGeneration
codeInterpreterEnableddataAnalyst
canvasEnabledcanvas
inputFieldsinputFields
actionsactions
attachmentsattachments

​
Schritt 3: Agent im Ziel-Workspace erstellen

Verwende die Agent Create API, um den Agenten im Ziel-Workspace zu erstellen: 
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: 
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,
      dataAnalyst: sourceAgent.codeInterpreterEnabled,
      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.
Schließe Aktionen von der initialen Migration aus und konfiguriere sie manuell im Ziel-Workspace, nachdem der Agent erstellt wurde.

​
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 hoch
  3. Aktualisiere den Agenten mit den neuen Anhangs-UUIDs

​
OAuth-Verbindungen

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.

​
Mehrere Agenten migrieren

Um mehrere Agenten zu migrieren, durchlaufe einfach eine Liste von Agenten-IDs: 
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

Behalte diese Einschränkungen bei der Planung deiner Migration im Hinterkopf:
  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
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.