> ## 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.

# Wissensdatenbank durchsuchen

> Führe eine semantische Suche über Wissensdatenbanken durch, die mit deinem API-Schlüssel geteilt sind

<Info>
  **Du nutzt unsere API in einem Dedicated Deployment?** Ersetze einfach `api.langdock.com` durch die Base URL deines Deployments: **`<deployment-url>/api/public`**
</Info>

Führt eine semantische Suche über alle Wissensdatenbanken durch, die mit deinem API-Schlüssel geteilt sind. Gibt relevante Dokumentenabschnitte zurück, sortiert nach Ähnlichkeit zu deiner Suchanfrage.

<Info>
  Erfordert einen API-Schlüssel mit dem `KNOWLEDGE_FOLDER_API` Scope. Die Suche umfasst alle Wissensdatenbanken, die mit dem API-Schlüssel geteilt sind. Siehe [Wissensdatenbank mit der API teilen](/de/developer/knowledge-folder-api/sharing) für die Einrichtung.
</Info>

## Wie es funktioniert

1. Deine Suchanfrage wird mit dem Standard-Embedding-Modell deines Workspace in ein Embedding umgewandelt
2. Das System führt eine Vektor-Ähnlichkeitssuche über alle Dokumente in geteilten Wissensdatenbankenn durch
3. Ergebnisse werden nach Relevanzschwelle gefiltert und mit einem LLM neu bewertet
4. Nur der am höchsten bewertete Abschnitt pro Dokument wird zurückgegeben

## Anforderungsformat

### Request Body

| Parameter | Typ    | Erforderlich | Beschreibung                                    |
| --------- | ------ | ------------ | ----------------------------------------------- |
| `query`   | string | Ja           | Die Suchanfrage zum Finden relevanter Dokumente |

## Beispiele

### Suche mit cURL

```bash theme={null}
curl -X POST "https://api.langdock.com/knowledge/search" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "Was sind die Q4 Umsatzprognosen?"}'
```

### Suche mit JavaScript

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

async function searchKnowledge(query) {
  const response = await axios.post(
    "https://api.langdock.com/knowledge/search",
    { query },
    {
      headers: {
        Authorization: "Bearer YOUR_API_KEY",
        "Content-Type": "application/json",
      },
    }
  );

  return response.data;
}

// Beispiel
const results = await searchKnowledge("Was sind die Q4 Umsatzprognosen?");
console.log(`${results.result.length} relevante Dokumente gefunden`);

results.result.forEach((chunk, i) => {
  console.log(`\n--- Ergebnis ${i + 1} ---`);
  console.log(`Datei: ${chunk.subname}`);
  console.log(`Ähnlichkeit: ${(chunk.similarity * 100).toFixed(1)}%`);
  console.log(`Text: ${chunk.text.substring(0, 200)}...`);
});
```

### Suchergebnisse für RAG verwenden

```javascript theme={null}
async function answerWithContext(question) {
  // Nach relevantem Kontext suchen
  const searchResults = await searchKnowledge(question);

  // Kontext aus Suchergebnissen erstellen
  const context = searchResults.result
    .map((chunk) => `Quelle: ${chunk.subname}\n${chunk.text}`)
    .join("\n\n---\n\n");

  // Kontext mit deinem LLM verwenden
  const prompt = `Basierend auf dem folgenden Kontext, beantworte die Frage.

Kontext:
${context}

Frage: ${question}

Antwort:`;

  // Deinen bevorzugten LLM-Endpunkt aufrufen
  return callLLM(prompt);
}
```

## Antwortformat

### Erfolgreiche Antwort (200 OK)

```typescript theme={null}
{
  status: "success";
  result: Array<{
    id: string;           // Eindeutige Chunk-ID
    text: string;         // Der Textinhalt des Chunks
    similarity: number;   // Ähnlichkeitswert (0-1)
    subsource: string;    // Attachment-ID
    subname: string;      // Dateiname
    url: string | null;   // Quell-URL, falls beim Upload angegeben
    index: number;        // Ergebnisindex (0-basiert)
  }>;
}
```

### Beispielantwort

```json theme={null}
{
  "status": "success",
  "result": [
    {
      "id": "chunk_abc123",
      "text": "Q4 Umsatzprognosen zeigen einen Anstieg von 15% im Vergleich zu Q3, hauptsächlich getrieben durch starke Enterprise-Verkäufe in der EMEA-Region...",
      "similarity": 0.89,
      "subsource": "att_xyz789",
      "subname": "quartalsbericht-2024.pdf",
      "url": "https://example.com/reports/q4-2024",
      "index": 0
    },
    {
      "id": "chunk_def456",
      "text": "Der prognostizierte Umsatz für das vierte Quartal berücksichtigt saisonale Trends und die Auswirkungen neuer Produkteinführungen...",
      "similarity": 0.82,
      "subsource": "att_abc456",
      "subname": "finanzprognose.xlsx",
      "url": null,
      "index": 1
    }
  ]
}
```

## Fehlerbehandlung

```typescript theme={null}
try {
  const response = await searchKnowledge(query);
} 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 KNOWLEDGE_FOLDER_API Scope");
        break;
      case 429:
        console.error("Rate Limit überschritten");
        break;
      case 500:
        console.error("Server-Fehler");
        break;
    }
  }
}
```

## Best Practices

**Schreibe klare, spezifische Suchanfragen** — Die Suche verwendet semantische Ähnlichkeit, daher funktionieren natürlichsprachliche Fragen gut. Sei spezifisch bei dem, was du suchst.

**Behandle leere Ergebnisse** — Wenn keine relevanten Dokumente gefunden werden, ist das `result` Array leer. Deine Anwendung sollte dies entsprechend behandeln.

**Nutze Ähnlichkeitswerte** — Der `similarity` Wert reicht von 0 bis 1. Höhere Werte bedeuten bessere Übereinstimmungen. Erwäge, Ergebnisse unter einem bestimmten Schwellenwert für deinen Anwendungsfall zu filtern.

**Quellenangaben** — Verwende die `subname` und `url` Felder, um Quellenangaben zu machen, wenn du Ergebnisse für Nutzer anzeigst.

<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>


## OpenAPI

````yaml post /knowledge/search
openapi: 3.0.0
info:
  title: Langdock API
  version: 3.0.0
servers:
  - url: https://api.langdock.com
    description: Production
security:
  - bearerAuth: []
paths:
  /knowledge/search:
    post:
      summary: Search through all files in data folders shared with the API Key
      parameters: []
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - query
              properties:
                query:
                  type: string
                  description: The search query
                  example: API Documentation
      responses:
        '200':
          description: Successfully found search result
      security:
        - bearerAuth: []
components:
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      bearerFormat: API Key
      description: API key as Bearer token. Format "Bearer YOUR_API_KEY"

````