Zum Hauptinhalt springen
POST
/
knowledge
/
{folderId}
Upload a file to a knowledge folder
curl --request POST \
  --url https://api.langdock.com/knowledge/{folderId} \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: multipart/form-data' \
  --form file='@example-file' \
  --form 'url=<string>'
import requests

url = "https://api.langdock.com/knowledge/{folderId}"

files = { "file": ("example-file", open("example-file", "rb")) }
payload = { "url": "<string>" }
headers = {"Authorization": "Bearer <token>"}

response = requests.post(url, data=payload, files=files, headers=headers)

print(response.text)
const form = new FormData();
form.append('file', '<string>');
form.append('url', '<string>');

const options = {method: 'POST', headers: {Authorization: 'Bearer <token>'}};

options.body = form;

fetch('https://api.langdock.com/knowledge/{folderId}', options)
.then(res => res.json())
.then(res => console.log(res))
.catch(err => console.error(err));
<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => "https://api.langdock.com/knowledge/{folderId}",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"; filename=\"example-file\"\r\nContent-Type: application/octet-stream\r\n\r\n<string>\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"url\"\r\n\r\n<string>\r\n-----011000010111000001101001--",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer <token>",
"Content-Type: multipart/form-data"
],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}
package main

import (
"fmt"
"strings"
"net/http"
"io"
)

func main() {

url := "https://api.langdock.com/knowledge/{folderId}"

payload := strings.NewReader("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"; filename=\"example-file\"\r\nContent-Type: application/octet-stream\r\n\r\n<string>\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"url\"\r\n\r\n<string>\r\n-----011000010111000001101001--")

req, _ := http.NewRequest("POST", url, payload)

req.Header.Add("Authorization", "Bearer <token>")

res, _ := http.DefaultClient.Do(req)

defer res.Body.Close()
body, _ := io.ReadAll(res.Body)

fmt.Println(string(body))

}
HttpResponse<String> response = Unirest.post("https://api.langdock.com/knowledge/{folderId}")
.header("Authorization", "Bearer <token>")
.body("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"; filename=\"example-file\"\r\nContent-Type: application/octet-stream\r\n\r\n<string>\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"url\"\r\n\r\n<string>\r\n-----011000010111000001101001--")
.asString();
require 'uri'
require 'net/http'

url = URI("https://api.langdock.com/knowledge/{folderId}")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"; filename=\"example-file\"\r\nContent-Type: application/octet-stream\r\n\r\n<string>\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"url\"\r\n\r\n<string>\r\n-----011000010111000001101001--"

response = http.request(request)
puts response.read_body
Du nutzt unsere API in einem Dedicated Deployment? Ersetze einfach api.langdock.com durch die Base URL deines Deployments: <deployment-url>/api/public
Lädt eine neue Datei in eine bestimmte Wissensdatenbank hoch. Die Datei wird verarbeitet, eingebettet und für die semantische Suche verfügbar gemacht.
Erfordert einen API-Schlüssel mit dem KNOWLEDGE_FOLDER_API Scope. Der API-Schlüssel selbst benötigt die Rolle Bearbeiter für die Wissensdatenbank. Siehe Wissensdatenbank mit der API teilen für die Einrichtung.

Anforderungsformat

Dieser Endpunkt akzeptiert multipart/form-data Anfragen mit der angehängten Datei.

Pfadparameter

ParameterTypErforderlichBeschreibung
folderIdstringJaDie ID der Wissensdatenbank

Formularfelder

FeldTypErforderlichBeschreibung
filefileJaDie hochzuladende Datei (max. 256MB)
urlstringNeinOptionale Quell-URL, die mit der Datei verknüpft wird

Unterstützte Dateitypen

Wissensdatenbanken unterstützen folgende Dokumenttypen:
  • PDF (.pdf)
  • Word-Dokumente (.doc, .docx)
  • Textdateien (.txt)
  • Markdown (.md)
  • HTML (.html)
  • PowerPoint (.pptx, .ppt)
Ausführbare Dateien und andere potenziell gefährliche Dateitypen werden aus Sicherheitsgründen blockiert.

Beispiele

Datei mit cURL hochladen

curl -X POST "https://api.langdock.com/knowledge/{folderId}" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "file=@/pfad/zu/dokument.pdf"

Datei mit JavaScript hochladen

const FormData = require("form-data");
const fs = require("fs");
const axios = require("axios");

async function uploadFile(folderId, filePath) {
  const form = new FormData();
  form.append("file", fs.createReadStream(filePath));

  const response = await axios.post(
    `https://api.langdock.com/knowledge/${folderId}`,
    form,
    {
      headers: {
        Authorization: "Bearer YOUR_API_KEY",
        ...form.getHeaders(),
      },
    }
  );

  return response.data;
}

Upload mit Quell-URL

const FormData = require("form-data");
const fs = require("fs");
const axios = require("axios");

async function uploadFileWithUrl(folderId, filePath, sourceUrl) {
  const form = new FormData();
  form.append("file", fs.createReadStream(filePath));
  form.append("url", sourceUrl);

  const response = await axios.post(
    `https://api.langdock.com/knowledge/${folderId}`,
    form,
    {
      headers: {
        Authorization: "Bearer YOUR_API_KEY",
        ...form.getHeaders(),
      },
    }
  );

  return response.data;
}

Antwortformat

Erfolgreiche Antwort (200 OK)

{
  status: "success";
  result: {
    id: string;          // Eindeutige Attachment-ID
    name: string;        // Originaler Dateiname
    mimeType: string;    // MIME-Typ der Datei
    createdAt: string;   // ISO 8601 Zeitstempel
    updatedAt: string;   // ISO 8601 Zeitstempel
    url: string | null;  // Quell-URL, falls angegeben
  };
}

Beispielantwort

{
  "status": "success",
  "result": {
    "id": "att_abc123def456",
    "name": "quartalsbericht.pdf",
    "mimeType": "application/pdf",
    "createdAt": "2025-01-15T10:30:00.000Z",
    "updatedAt": "2025-01-15T10:30:00.000Z",
    "url": null
  }
}

Fehlerbehandlung

try {
  const response = await uploadFile(folderId, filePath);
} catch (error) {
  if (error.response) {
    switch (error.response.status) {
      case 400:
        console.error("Ungültige Anfrage:", error.response.data.message);
        break;
      case 401:
        console.error("Ungültiger oder fehlender API-Schlüssel");
        break;
      case 403:
        console.error("API-Schlüssel hat keinen Zugriff auf diese Wissensdatenbank");
        break;
      case 404:
        console.error("Wissensdatenbank nicht gefunden");
        break;
      case 408:
        console.error("Upload-Anfrage hat das Zeitlimit überschritten");
        break;
      case 413:
        console.error("Dateigröße überschreitet das 256MB-Limit");
        break;
      case 429:
        console.error("Rate Limit überschritten");
        break;
      case 500:
        console.error("Server-Fehler");
        break;
    }
  }
}

Verarbeitungsstatus

Nach dem Upload wird die Datei asynchron verarbeitet. Verwende den Dateien abrufen Endpunkt, um den Verarbeitungsstatus zu prüfen. Das syncStatus Feld zeigt den aktuellen Zustand:
  • UPLOADING - Datei wird hochgeladen
  • UPLOADED - Datei ist hochgeladen und in der Warteschlange
  • EXTRACTING - Text wird aus der Datei extrahiert
  • EMBEDDING - Embeddings werden generiert
  • SYNCED - Datei ist bereit für die Suche
  • ACTION_FAILED, EXTRACTION_FAILED, EMBEDDING_FAILED, TIMEOUT - Verarbeitung fehlgeschlagen

Asynchrone Upload-Variante

Für große Dateien oder wenn du nicht auf die Upload-Antwort warten musst, kannst du den asynchronen Upload-Endpunkt verwenden:
POST /knowledge/{folderId}/upload-async
Dieser Endpunkt akzeptiert die gleichen multipart/form-data Felder und gibt 202 Accepted zurück, sobald die Datei empfangen wurde. Die Verarbeitung läuft im Hintergrund weiter.
{
  "status": "processing",
  "result": {
    "id": "att_abc123def456",
    "name": "quartalsbericht.pdf",
    "mimeType": "application/pdf",
    "createdAt": "2025-01-15T10:30:00.000Z",
    "updatedAt": "2025-01-15T10:30:00.000Z",
    "url": null,
    "processingStatus": "UPLOADED",
    "statusUrl": "/api/public/knowledge/{folderId}/{attachmentId}"
  },
  "message": "File uploaded successfully and is being processed in the background. Poll the statusUrl to check when processing completes (syncStatus: SYNCED)."
}
Nutze GET {statusUrl}, um den Verarbeitungsstatus abzufragen. Die Antwort gibt den aktuellen Status in result.syncStatus zurück.
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.

Autorisierungen

Authorization
string
header
erforderlich

API key as Bearer token. Format "Bearer YOUR_API_KEY"

Pfadparameter

folderId
string
erforderlich

The ID of the knowledge folder

Body

multipart/form-data
file
file

The file to upload

url
string

The associated URL

Antwort

200

File uploaded successfully