Text-Bewertung und Analyse

Eine Reihe von Texten bewerten

POST/api/v1/workspaces/{workspaceId}/text-scores

Bewerten Sie einen oder mehrere vollständige Texte anhand eines Einbettungsmodells entlang der angeforderten Dimensionen und Mapper. Wenn goalConfig bereitgestellt wird, wird ein kombinierter goalScore pro Text sowie eine Aufschlüsselung der beitragenden goalScoreFactors zurückgegeben.

Pfadparameter

Parameter	Typ	Erforderlich	Beschreibung
`workspaceId`	string	Ja	Der Arbeitsbereich, auf den die Anfrage operiert. Muss mit dem Workspace-Anspruch im Gateway-Token übereinstimmen.

Anfrage-Body

textsarray<string>JaZu bewertende Texte. Jeder Text wird mit seinen eigenen Wertungen in data zurückgegeben.

embeddingModelIdstringJaID des Einbettungsmodells, das bewertet werden soll (siehe GET /embedding-models).

goalConfigobjectNeinDefinition des Ziels, auf das ein Bewertungslauf optimiert wird. Ein Ziel kombiniert eine optionale modelRankScore-Präferenz, optionale Pro-Dimension-Gewichte und optionale Pro-Mapper-Gewichte sowie eine Normalisierungsstrategie.

modelRankScorenumberNeinWortfrequenz-Präferenz von -1 (nur seltene Wörter zählen positiv) bis 1 (nur sehr häufige).

dimensionsarray<object>NeinPro-Dimension-Gewichte, aus denen sich das Ziel zusammensetzt.

idintegerJaDimensions-ID, die der id eines Eintrags in dimensions entspricht.

weightintegerJaRichtung, in der ein Faktor die Zielwertung beeinflusst.

mappersarray<object>NeinPro-Mapper-Gewichte, aus denen sich das Ziel zusammensetzt.

idstringJaMapper-ID, die der id eines Eintrags in mappers entspricht.

weightintegerJaRichtung, in der ein Faktor die Zielwertung beeinflusst.

normalizationstringNeinNormalisierung, die auf Pro-Faktor-Wertungen angewendet wird, bevor sie kombiniert werden.

dimensionsarray<object>NeinSemantische Dimensionen, anhand derer jeder Text bewertet wird.

idintegerJaInterne Dimensions-ID. Wiederholen Sie diese ID in goalConfig.dimensions[].id, um der Dimension eine Gewichtung zu geben.

wordsarray<string>NeinSeed-Wörter, die diese Dimension definieren. Direkt verwendet, wenn type manual ist; zusammengeführt mit den gespeicherten Seeds der Dimension, wenn type dimension ist.

typestringJaOb die Dimension von einer bekannten Dimension oder von manuellen Seed-Wörtern abgeleitet ist.

namestringNeinOptionaler Anzeigename für Analytics/UI.

mapperKeysarray<string>NeinZusammengesetzte Mapper-Variablen-IDs, anhand derer jeder Text bewertet wird. Jede ID entspricht der id, die von GET /mappers zurückgegeben wird (z. B. en_emotions_standard_valence).

Antwort

dataarray<object>Bewertete Texte in der Reihenfolge, in der sie eingereicht wurden.

modelRankScorenumberWertung, die widerspiegelt, wie häufig die in diesem Text verwendeten Wörter im Vokabular des Einbettungsmodells vorkommen.

goalScoreFactorsarray<object>Aufschlüsselung der Faktoren, die zu goalScore beigetragen haben. Leer, wenn keine goalConfig bereitgestellt wurde.

fieldstringName des Faktors (Dimension/Mapper/Intrinsisch), der beigetragen hat.

valuenumberNumerischer Beitrag dieses Faktors zur kombinierten Zielwertung.

typestringKategorie des Faktors (z. B. dimension, mapper, intrinsic).

dimensionScoresobjectPro-Dimension-Wertungen mit Schlüssel str(dimension.id).

mapperScoresobjectPro-Mapper-Variablen-Wertungen mit Schlüssel Mapper id.

goalScorenumberKombinierter Zielwert-Score (nur gesetzt, wenn goalConfig vorhanden ist).

Beispiel

cURL
Python
Node.js
Go

curl -X POST "https://app.neuroflash.com/api/v1/workspaces/{workspace_id}/text-scores" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
      "texts": [],
      "embeddingModelId": "string",
      "goalConfig": {},
      "dimensions": [],
      "mapperKeys": []
  }'

import requests

response = requests.post(
    f"https://app.neuroflash.com/api/v1/workspaces/{workspace_id}/text-scores",
    headers={"Authorization": f"Bearer {token}", "Content-Type": "application/json"},
    json={
        "texts": [],
        "embeddingModelId": "string",
        "goalConfig": {},
        "dimensions": [],
        "mapperKeys": []
    },
).json()

const response = await fetch(
  `https://app.neuroflash.com/api/v1/workspaces/${workspaceId}/text-scores`,
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${token}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
          "texts": [],
          "embeddingModelId": "string",
          "goalConfig": {},
          "dimensions": [],
          "mapperKeys": []
    }),
  }
).then((r) => r.json());

body, _ := json.Marshal(map[string]any{
		"texts": []any{},
		"embeddingModelId": "string",
		"goalConfig": map[string]any{},
		"dimensions": []any{},
		"mapperKeys": []any{},
	})

req, _ := http.NewRequest("POST", "https://app.neuroflash.com/api/v1/workspaces/"+workspaceID+"/text-scores", bytes.NewReader(body))
req.Header.Set("Authorization", "Bearer "+token)
req.Header.Set("Content-Type", "application/json")

resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

Antwort:

{
  "data": [
    {
      "modelRankScore": 0.32,
      "goalScoreFactors": [
        {
          "field": "...",
          "value": "...",
          "type": "..."
        }
      ],
      "dimensionScores": {
        "29": 0.71
      },
      "mapperScores": {
        "en_emotions_standard_valence": 0.65
      },
      "goalScore": 0.58
    }
  ]
}

Wörter gegen ein Seed-Konzept bewerten

POST/api/v1/workspaces/{workspaceId}/word-scores

Nehmen Sie eine Reihe von Seed-Konzepten (seedWords) und geben Sie bewertete Kandidatenwörter gegen ein Embedding-Modell zurück. Für jedes Kandidatenwort enthält die Antwort:

seedScore — semantische Ähnlichkeit zum Centroid der Seed-Wörter (Kosinusähnlichkeit, Bereich ungefähr -1..1)
modelRank — der Häufigkeitsrang des Wortes im Vokabular des Embedding-Modells (niedriger bedeutet häufiger)
dimensionScores — pro-Achsen-Scores für jeden Eintrag in dimensions (z. B. wie „frisch" oder „luxuriös" das Wort wirkt)
mapperScores — pro-Variable-Scores für jede ID in mapperKeys (z. B. Valenz, Arousal)
goalScore — nur gefüllt, wenn seedScore Gewichtung in der Anfrage gesetzt ist; entspricht seedScore_weight * seed_similarity

Zwei Modi, gesteuert durch whitelistWords:

Eine feste Liste bewerten. Senden Sie ein nicht-leeres whitelistWords und nur diese Wörter werden bewertet.
Suchen und bewerten. Lassen Sie whitelistWords leer und der Service wählt die limit Wörter aus dem Embedding-Vokabular aus, die seedWords am nächsten kommen (weiter eingegrenzt durch wordrankLimit falls angegeben), und bewertet diese dann.

Typischer Anwendungsfall: Optimierung von Marketing-Keywords — geben Sie Ihre Kampagnenkonzepte in seedWords und eine Liste von Kandidaten-Keywords in whitelistWords an, um diese zu bewerten, oder verzichten Sie auf die Whitelist und lassen Sie den Service frische Vorschläge auftauchen.

Pfadparameter

Parameter	Typ	Erforderlich	Beschreibung
`workspaceId`	string	Ja	Der Arbeitsbereich, auf den die Anfrage operiert. Muss mit dem Workspace-Anspruch im Gateway-Token übereinstimmen.

Anfrage-Body

seedWordsarray<string>JaAnker-Wörter für den Durchlauf. Ihr Centroid definiert, wogegen seedScore und das pro-Wort-Feld seedScore Ähnlichkeit messen. Im Find-and-Score-Modus (leeres whitelistWords) wird die Kandidatenmenge auch aus der Nähe dieses Centroids gezogen.

whitelistWordsarray<string>NeinBeschränken Sie die Bewertung auf genau diese Wörter. Wenn leer, läuft der Service im Find-and-Score-Modus und wählt Kandidaten aus dem Vokabular des Embedding-Modells.

embeddingModelIdstringJaID des Embedding-Modells, dessen Vokabular und Vektorraum die Bewertung läuft. Siehe GET /embedding-models.

limitintegerNeinNur Find-and-Score-Modus: maximale Anzahl von Kandidatenwörtern, die vor der Bewertung aus dem Vokabular gezogen werden sollen. Ignoriert, wenn whitelistWords nicht leer ist.

wordrankLimitintegerNeinHäufigkeitsschwelle bei der Kandidatenauswahl: nur Wörter unter den Top-N häufigsten des Vokabulars sind berechtigt. -1 deaktiviert die Schwelle. Hat keine Auswirkung, wenn whitelistWords vorhanden ist.

seedScorenumberNeinGewichtung des pro-Wort-Seed-Ähnlichkeitsfaktors bei der Berechnung des kombinierten goalScore. Bereich -1 (Wörter nah am Seed benachteiligen) bis 1 (Wörter nah am Seed bevorzugen). null deaktiviert die Zielwert-Berechnung vollständig. In diesem Fall sind die goalScore-Felder in der Antwort auch null.

dimensionsarray<object>NeinSemantische Dimensionen, gegen die jedes Wort bewertet werden soll. Jeder Eintrag trägt einen pro-Wort-Wert dimensionScores in der Antwort bei.

idintegerJaInterne Dimensions-ID. Wiederholen Sie diese ID in goalConfig.dimensions[].id, um der Dimension eine Gewichtung zu geben.

typestringJaOb die Dimension von einer bekannten Dimension oder von manuellen Seed-Wörtern abgeleitet ist.

namestringNeinOptionaler Anzeigename für Analytics/UI.

mapperKeysarray<string>NeinZusammengesetzte Mapper-Variablen-IDs zum Bewerten jedes Wortes. Jede ID entspricht der id, die von GET /mappers zurückgegeben wird (z. B. en_emotions_standard_valence). Jede ID trägt einen pro-Wort-Wert mapperScores in der Antwort bei.

Antwort

dataarray<object>Bewertete Wörter, die von der Anfrage zurückgegeben werden.

wordstringDas bewertete Wort, in Kleinbuchstaben.

seedScorenumberSemantische Ähnlichkeit mit den Seed-Wörtern der Anfrage. null, wenn kein Seed bereitgestellt wurde (Whitelist-Modus).

modelRankintegerHäufigkeitsrang im Vokabular des Embedding-Modells (niedriger = häufiger).

seedScoreQuartileintegerQuartil-Zuweisung innerhalb der bewerteten Menge; -1 bedeutet unzugewiesen.

modelRankQuartileintegerQuartil-Zuweisung innerhalb der bewerteten Menge; -1 bedeutet unzugewiesen.

dimensionScoresobjectPro-Dimensions-Scores mit Schlüsseln nach str(dimension.id). Fehlende Werte werden weggelassen (verwenden Sie 0 als Fallback in Clients).

mapperScoresobjectPro-Mapper-Variablen-Scores mit Schlüsseln nach Mapper-id. Fehlende Werte werden weggelassen.

goalScorenumberKombinierter Zielwert-Score (nur gesetzt, wenn goalConfig vorhanden ist).

averagesobjectDurchschnittswerte über alle bewerteten Wörter für dieselbe Anfrage.

modelRankScorenumberDurchschnittlicher Model-Rank-Score über die bewertete Menge.

seedScorenumberDurchschnittlicher Seed-Ähnlichkeits-Score über die bewertete Menge.

dimensionScoresobjectPro-Dimension-Durchschnitte mit Schlüssel str(dimension.id).

mapperScoresobjectPro-Mapper-Durchschnitte mit Schlüssel Mapper id.

goalScorenumberDurchschnittliche Zielwertung (nur gesetzt, wenn goalConfig bereitgestellt wird).

Beispiel

cURL
Python
Node.js
Go

curl -X POST "https://app.neuroflash.com/api/v1/workspaces/{workspace_id}/word-scores" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
      "seedWords": [],
      "whitelistWords": [],
      "embeddingModelId": "string",
      "limit": 100,
      "wordrankLimit": -1,
      "seedScore": 0,
      "dimensions": [],
      "mapperKeys": []
  }'

import requests

response = requests.post(
    f"https://app.neuroflash.com/api/v1/workspaces/{workspace_id}/word-scores",
    headers={"Authorization": f"Bearer {token}", "Content-Type": "application/json"},
    json={
        "seedWords": [],
        "whitelistWords": [],
        "embeddingModelId": "string",
        "limit": 100,
        "wordrankLimit": -1,
        "seedScore": 0,
        "dimensions": [],
        "mapperKeys": []
    },
).json()

const response = await fetch(
  `https://app.neuroflash.com/api/v1/workspaces/${workspaceId}/word-scores`,
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${token}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
          "seedWords": [],
          "whitelistWords": [],
          "embeddingModelId": "string",
          "limit": 100,
          "wordrankLimit": -1,
          "seedScore": 0,
          "dimensions": [],
          "mapperKeys": []
    }),
  }
).then((r) => r.json());

body, _ := json.Marshal(map[string]any{
		"seedWords": []any{},
		"whitelistWords": []any{},
		"embeddingModelId": "string",
		"limit": 100,
		"wordrankLimit": -1,
		"seedScore": 0,
		"dimensions": []any{},
		"mapperKeys": []any{},
	})

req, _ := http.NewRequest("POST", "https://app.neuroflash.com/api/v1/workspaces/"+workspaceID+"/word-scores", bytes.NewReader(body))
req.Header.Set("Authorization", "Bearer "+token)
req.Header.Set("Content-Type", "application/json")

resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

Antwort:

{
  "data": [
    {
      "word": "innovative",
      "seedScore": 0.42,
      "modelRank": 1234,
      "seedScoreQuartile": 0,
      "modelRankQuartile": 0,
      "dimensionScores": {
        "29": 0.71
      },
      "mapperScores": {
        "en_emotions_standard_valence": 0.65
      },
      "goalScore": 0.58
    }
  ],
  "averages": {
    "modelRankScore": 0.32,
    "seedScore": 0.45,
    "dimensionScores": {
      "29": 0.62
    },
    "mapperScores": {
      "en_emotions_standard_valence": 0.58
    },
    "goalScore": 0.55
  }
}

Text auf Plagiate prüfen

POST/api/v1/workspaces/{workspaceId}/plagiarism-checks

Scan einen Textabschnitt auf wörtliche Übereinstimmungen im öffentlichen Web über den vorgelagerten Plagiatsprüfdienst. Die Eingabe muss mindestens 15 Wörter enthalten. Gibt die Gesamtwortanzahl der Eingabe sowie eine Liste von Quellen zurück, in denen übereinstimmende Passagen gefunden wurden, einschließlich eines matchPercentage pro Quelle.

Die Quote wird durch den Nutzungsdienst gegen das plagiarismChecks-Budget des Arbeitsbereichs durchgesetzt — Aufrufer, die ihre monatliche Zuteilung erschöpft haben, erhalten 403 mit ERROR_NO_REMAINING_PLAGIARISM_CHECKS. Jeder erfolgreiche Aufruf erhöht den Zähler um eins.

Pfadparameter

Parameter	Typ	Erforderlich	Beschreibung
`workspaceId`	string	Ja	Der Arbeitsbereich, auf den die Anfrage operiert. Muss mit dem Workspace-Anspruch im Gateway-Token übereinstimmen.

Anfrage-Body

textstringJaDer Text, der auf Plagiate überprüft werden soll. Muss nach dem Entfernen von Satzzeichen mindestens 15 Wörter enthalten, sonst wird die Anfrage mit dem Übersetzungsschlüssel plagiarismTextTooShort abgelehnt.

Antwort

wordCountintegerGesamtanzahl der Wörter in der Eingabe text (nach Satzzeichen-Entfernung).

matchesarray<object>Quellen im öffentlichen Web, die Passagen enthalten, die mit der Eingabe text übereinstimmen. Leer, wenn kein Plagiat erkannt wurde.

urlstringURL der externen Seite, auf der die Übereinstimmung gefunden wurde.

titlestringHTML <title> der Seite, auf der die Übereinstimmung gefunden wurde.

matchSnippetstringAusschnitt der übereinstimmenden Passage, normalerweise mit umgebendem Kontext. Geeignet zum Hervorheben in der Benutzeroberfläche.

wordsMatchedintegerAnzahl der Wörter im Eingabetext, die mit dieser Quelle übereinstimmen.

matchPercentagenumberBruchteil des Eingabetexts, der mit dieser Quelle übereinstimmt, ausgedrückt als Prozentsatz im Bereich 0–100.

Beispiel

cURL
Python
Node.js
Go

curl -X POST "https://app.neuroflash.com/api/v1/workspaces/{workspace_id}/plagiarism-checks" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
      "text": "string"
  }'

import requests

response = requests.post(
    f"https://app.neuroflash.com/api/v1/workspaces/{workspace_id}/plagiarism-checks",
    headers={"Authorization": f"Bearer {token}", "Content-Type": "application/json"},
    json={
        "text": "string"
    },
).json()

const response = await fetch(
  `https://app.neuroflash.com/api/v1/workspaces/${workspaceId}/plagiarism-checks`,
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${token}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
          "text": "string"
    }),
  }
).then((r) => r.json());

body, _ := json.Marshal(map[string]any{
		"text": "string",
	})

req, _ := http.NewRequest("POST", "https://app.neuroflash.com/api/v1/workspaces/"+workspaceID+"/plagiarism-checks", bytes.NewReader(body))
req.Header.Set("Authorization", "Bearer "+token)
req.Header.Set("Content-Type", "application/json")

resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

Antwort:

{
  "wordCount": 28,
  "matches": [
    {
      "url": "https://en.wikipedia.org/wiki/Example_Person",
      "title": "Example Person - Wikipedia",
      "matchSnippet": "She was born in Sydney and studied English Literature and Law at the University of New South Wales...",
      "wordsMatched": 24,
      "matchPercentage": 84.5
    }
  ]
}

Text tokenisieren

POST/api/v1/workspaces/{workspaceId}/tokenizations

Teilen Sie einen Textabschnitt in Tokens mit dem Tokenizer für die angegebene language auf. Jeder Token trägt seine Oberflächenform, normalisierte Form, Zeichenversätze im Originaltext, ein Stoppwort-Flag und (falls verfügbar) eine Liste von Synonymen. Die Antwort enthält auch tokenCount zur Vereinfachung.

Pfadparameter

Parameter	Typ	Erforderlich	Beschreibung
`workspaceId`	string	Ja	Der Arbeitsbereich, auf den die Anfrage operiert. Muss mit dem Workspace-Anspruch im Gateway-Token übereinstimmen.

Anfrage-Body

languagestringJaISO 639-1-Sprachcode, der auswählt, welcher Tokenizer/welches Modell verwendet wird, z. B. en, de, fr, ja.

textstringJaDer Text, der tokenisiert werden soll.

Antwort

tokenCountintegerGesamtzahl der zurückgegebenen Token. Gleich wie len(tokens).

tokensarray<object>Die aus dem Eingabetext erzeugten Token in ihrer ursprünglichen Reihenfolge.

stringstringDer ursprüngliche Substring der Eingabe, den dieses Token abdeckt.

tokenstringDie normalisierte/lemmatisierte Form des Tokens, die für die nachgelagerte Verarbeitung verwendet wird. Bei japanischen Eingaben ist dies identisch mit string.

indexStartintegerNullbasierter Zeichenversatz, bei dem dieses Token in der Eingabe beginnt.

indexEndintegerNullbasierter Zeichenversatz, bei dem dieses Token in der Eingabe endet (ausschließlich).

isStopbooleanOb das Token in der gewählten Sprache als Stoppwort betrachtet wird (z. B. the, and, of im Englischen).

synonymsarray<string>Synonyme des Tokens, falls für diese Sprache verfügbar. Leere Liste, wenn keine Synonyme gefunden wurden.

Beispiel

cURL
Python
Node.js
Go

curl -X POST "https://app.neuroflash.com/api/v1/workspaces/{workspace_id}/tokenizations" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
      "language": "string",
      "text": "string"
  }'

import requests

response = requests.post(
    f"https://app.neuroflash.com/api/v1/workspaces/{workspace_id}/tokenizations",
    headers={"Authorization": f"Bearer {token}", "Content-Type": "application/json"},
    json={
        "language": "string",
        "text": "string"
    },
).json()

const response = await fetch(
  `https://app.neuroflash.com/api/v1/workspaces/${workspaceId}/tokenizations`,
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${token}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
          "language": "string",
          "text": "string"
    }),
  }
).then((r) => r.json());

body, _ := json.Marshal(map[string]any{
		"language": "string",
		"text": "string",
	})

req, _ := http.NewRequest("POST", "https://app.neuroflash.com/api/v1/workspaces/"+workspaceID+"/tokenizations", bytes.NewReader(body))
req.Header.Set("Authorization", "Bearer "+token)
req.Header.Set("Content-Type", "application/json")

resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

Antwort:

{
  "tokenCount": 5,
  "tokens": [
    {
      "string": "Angela",
      "token": "angela",
      "indexStart": 0,
      "indexEnd": 6,
      "isStop": false,
      "synonyms": []
    }
  ]
}

Vervollständigungen für ein Teilwort vorschlagen

POST/api/v1/workspaces/{workspaceId}/autocomplete-suggestions

Geben Sie bis zu zehn Vorschläge für ein teilweise eingegebenes Wort zurück, die aus dem Vokabular des bereitgestellten Einbettungsmodells stammen. Verwenden Sie das Feld whitelistWords, um die Kandidatenmenge einzuschränken (z. B. auf ein kampagnenspezifisches Glossar).

Typischer Anwendungsfall: Automatische Inline-Vervollständigung in einer Bearbeitungsoberfläche für Texte.

Pfadparameter

Parameter	Typ	Erforderlich	Beschreibung
`workspaceId`	string	Ja	Der Arbeitsbereich, auf den die Anfrage operiert. Muss mit dem Workspace-Anspruch im Gateway-Token übereinstimmen.

Anfrage-Body

wordstringJaTeilwort, für das der Aufrufer Vervollständigungen wünscht. Wird als Präfix behandelt und mit dem Vokabular des Einbettungsmodells abgeglichen.

embeddingModelIdstringJaID des Einbettungsmodells, dessen Vokabular-Vervollständigungen verwendet werden (siehe GET /embedding-models).

whitelistWordsarray<string>NeinWenn nicht leer, werden nur Vervollständigungen aus dieser Whitelist zurückgegeben. Nützlich, um die Autocompletion auf ein kampagnenspezifisches Glossar zu beschränken.

Antwort

suggestionsarray<string>Bis zu zehn empfohlene Vervollständigungen, geordnet von beste zu schlechteste.

Beispiel

cURL
Python
Node.js
Go

curl -X POST "https://app.neuroflash.com/api/v1/workspaces/{workspace_id}/autocomplete-suggestions" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
      "word": "string",
      "embeddingModelId": "string",
      "whitelistWords": []
  }'

import requests

response = requests.post(
    f"https://app.neuroflash.com/api/v1/workspaces/{workspace_id}/autocomplete-suggestions",
    headers={"Authorization": f"Bearer {token}", "Content-Type": "application/json"},
    json={
        "word": "string",
        "embeddingModelId": "string",
        "whitelistWords": []
    },
).json()

const response = await fetch(
  `https://app.neuroflash.com/api/v1/workspaces/${workspaceId}/autocomplete-suggestions`,
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${token}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
          "word": "string",
          "embeddingModelId": "string",
          "whitelistWords": []
    }),
  }
).then((r) => r.json());

body, _ := json.Marshal(map[string]any{
		"word": "string",
		"embeddingModelId": "string",
		"whitelistWords": []any{},
	})

req, _ := http.NewRequest("POST", "https://app.neuroflash.com/api/v1/workspaces/"+workspaceID+"/autocomplete-suggestions", bytes.NewReader(body))
req.Header.Set("Authorization", "Bearer "+token)
req.Header.Set("Content-Type", "application/json")

resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

Antwort:

{
  "suggestions": [
    "multicolored",
    "multihued"
  ]
}

Eine Reihe von Texten bewerten​

Pfadparameter​

Anfrage-Body​

Antwort​

Beispiel​

Wörter gegen ein Seed-Konzept bewerten​

Pfadparameter​

Anfrage-Body​

Antwort​

Beispiel​

Text auf Plagiate prüfen​

Pfadparameter​

Anfrage-Body​

Antwort​

Beispiel​

Text tokenisieren​

Pfadparameter​

Anfrage-Body​

Antwort​

Beispiel​

Vervollständigungen für ein Teilwort vorschlagen​

Pfadparameter​

Anfrage-Body​

Antwort​

Beispiel​

Eine Reihe von Texten bewerten

Pfadparameter

Anfrage-Body

Antwort

Beispiel

Wörter gegen ein Seed-Konzept bewerten

Pfadparameter

Anfrage-Body

Antwort

Beispiel

Text auf Plagiate prüfen

Pfadparameter

Anfrage-Body

Antwort

Beispiel

Text tokenisieren

Pfadparameter

Anfrage-Body

Antwort

Beispiel

Vervollständigungen für ein Teilwort vorschlagen

Pfadparameter

Anfrage-Body

Antwort

Beispiel