Am 6. November 2023 kündigte OpenAI die Veröffentlichung ihrer GPTs an. Auf dieser No-Code-Plattform können Sie als professioneller (oder Hobby-)Entwickler individuelle GPTs oder Chatbots mit Ihren eigenen Tools und Eingabeaufforderungen erstellen und somit Ihre Interaktionen mit OpenAI's GPTs effektiv verändern. Bisher war es erforderlich, dynamische Eingabeaufforderungen zu verwenden, um Antworten von GPT mit LangChain (opens new window) oder LlamaIndex (opens new window) abzurufen. Jetzt übernehmen die OpenAI GPTs die dynamische Eingabeaufforderung, indem sie externe APIs oder Tools aufrufen.
Dies ändert auch die Art und Weise, wie wir (bei MyScale) RAG-Systeme erstellen, von der Erstellung von Eingabeaufforderungen mit serverseitigem Kontext bis hin zur Einbindung dieses Kontextes in das GPTs-Modell.
MyScale vereinfacht die Art und Weise, wie Sie Kontexte in Ihre GPTs einfügen. Zum Beispiel lädt OpenAI Dateien über eine Web-Benutzeroberfläche auf die GPTs-Plattform hoch. Im Gegensatz dazu ermöglicht Ihnen MyScale die Kombination von strukturierter Datenfilterung und semantischer Suche mithilfe einer SQL WHERE-Klausel (opens new window), die Verarbeitung und Speicherung einer viel größeren Wissensdatenbank zu geringeren Kosten sowie die gemeinsame Nutzung einer Wissensdatenbank über mehrere GPTs hinweg.
Probieren Sie jetzt MyScaleGPT 🚀 im GPT Store aus oder integrieren Sie die offene Wissensdatenbank von MyScale noch heute in Ihre App mit unserer API, gehostet auf Hugging Face:
# BYOK: Bringen Sie Ihr eigenes Wissen mit
GPT hat sich im letzten Jahr erheblich weiterentwickelt und verfügt über einen viel größeren Wissensbereich als bei seiner ersten Veröffentlichung. Es gibt jedoch immer noch spezifische Themen, von denen es nichts weiß oder unsicher ist - wie domänenspezifisches Wissen und aktuelle Ereignisse. Daher ist es, wie in unseren früheren Artikeln (opens new window) beschrieben, zwingend erforderlich, eine externe Wissensdatenbank, die in MyScale gespeichert ist, in GPT zu integrieren, um dessen Wahrheitsgehalt und Hilfsbereitschaft zu steigern.
Als wir RAG mit MyScale aufgebaut haben (opens new window), haben wir einen LLM in unsere Kette (oder unseren Stack) aufgenommen. Dieses Mal müssen wir eine MyScale-Datenbank auf die GPTs-Plattform bringen. Leider ist es derzeit nicht möglich, eine direkte Verbindung zwischen GPTs und MyScale herzustellen. Daher haben wir die Abfrage-Schnittstelle angepasst und sie als REST-API freigegeben.
Aufgrund unseres früheren Erfolgs mit OpenAI-Funktionsaufrufen (opens new window) können wir jetzt eine ähnliche Schnittstelle entwerfen, bei der GPT Vektor-Suchabfragen mit SQL-ähnlichen Filterzeichenketten erstellen kann. Die Parameter werden wie folgt in OpenAPI (opens new window) geschrieben:
"parameters": [
{
"name": "subject",
"in": "query",
"description": "A sentence or phrase describes the subject you want to query.",
"required": true,
"schema": {
"type": "string"
}
},
{
"name": "where_str",
"in": "query",
"description": "a SQL-like where string to build filter",
"required": true,
"schema": {
"type": "string"
}
},
{
"name": "limit",
"in": "query",
"description": "desired number of retrieved documents",
"schema": {
"type": "integer",
"default": 4
}
}
]
Mit einer solchen Schnittstelle kann GPT Schlüsselwörter extrahieren, um die gewünschte Abfrage mit in SQL geschriebenen Filtern zu beschreiben.
# Bereitstellung von Abfrageeinträgen für verschiedene Tabellen
Manchmal müssen wir möglicherweise verschiedene Tabellen abfragen. Dies kann mit separaten API-Einträgen implementiert werden. Jeder API-Eintrag enthält sein eigenes Schema und seine eigenen Eingabeaufforderungen in der Dokumentation. GPTs lesen die entsprechende API-Dokumentation und schreiben die richtigen Abfragen für die entsprechende Tabelle.
Bemerkenswerterweise erfordern die zuvor eingeführten Methoden wie selbstabfragende Retriever (opens new window) und Vektor-SQL (opens new window) dynamische oder halbdynamische Eingabeaufforderungen, um die Tabellenstruktur zu beschreiben. Im Gegensatz dazu funktionieren GPTs wie konversationelle Agenten in LangChain (opens new window), bei denen Agenten verschiedene Tools verwenden, um Tabellen abzufragen.
Die API-Einträge können zum Beispiel in OpenAPI 3.0 wie folgt geschrieben werden:
"paths": {
// Abfrageeintritt für die Tabelle arxiv
"/get_related_arxiv": {
"get": {
// Beschreibungen werden in die Eingabeaufforderung eingefügt
// damit GPT weiß, wie und wann dieses Abfragetool verwendet werden soll
"description": "Get some related papers."
"You should use schema here:\n"
"CREATE TABLE ArXiv ("
" `id` String,"
" `abstract` String,"
" `pubdate` DateTime,"
" `title` String,"
" `categories` Array(String), -- arxiv category"
" `authors` Array(String),"
" `comment` String,"
"ORDER BY id",
"operationId": "get_related_arxiv",
"parameters": [
// oben erwähnte Parameter
],
}
},
// Abfrageeintritt für die Tabelle wiki
"/get_related_wiki": {
"get": {
"description": "Get some related wiki pages. "
"You should use schema here:\n\n"
"CREATE TABLE Wikipedia ("
" `id` String,"
" `text` String,"
" `title` String,"
" `view` Float32,"
" `url` String, -- URL to this wiki page"
"ORDER BY id\n"
"You should avoid using LIKE on long text columns.",
"operationId": "get_related_wiki",
"parameters": [
// oben erwähnte Parameter
]
}
}
}
Basierend auf diesem Code-Snippet weiß GPT, dass es zwei Wissensdatenbanken gibt, die helfen können, die Fragen des Benutzers zu beantworten.
Nachdem die GPT Actions für den Abruf der Wissensdatenbank konfiguriert wurden, füllen wir einfach die Instructions aus und geben der GPT an, wie die Wissensdatenbanken abgefragt werden sollen, um dann die Benutzerfrage zu beantworten:
Versuchen Sie, die Fragen bestmöglich zu beantworten. Nutzen Sie gerne alle verfügbaren Tools, um relevante Informationen nachzuschlagen. Bitte behalten Sie bei Aufrufen von Suchfunktionen alle Details in der Abfrage. Bei Abfragen mit MyScale-Wissensdatenbanken verwenden Sie für ein Array von Zeichenketten bitte
has(column, value to match). Für das Veröffentlichungsdatum verwenden SieparseDateTime32BestEffort(), um Zeitstempelwerte von Zeichenkettenformat in Datum-Zeit-Objekte umzuwandeln. Sie konvertieren die Spalten mit Datum-Zeit-Typ niemals mit dieser Funktion. Fügen Sie immer Referenzlinks zu den verwendeten Dokumenten hinzu.
# Hosting Ihrer Datenbank als OpenAPI
GPTs passen APIs an den OpenAI 3.0-Standard an. Einige Anwendungen wie Datenbanken haben jedoch keine OpenAPI-Schnittstellen. Daher müssen wir Middleware verwenden, um GPTs mit MyScale zu integrieren.
Wir haben unsere Datenbank mit OpenAI-kompatiblen Schnittstellen auf Hugging Face (opens new window) gehostet. Wir haben flask-restx (opens new window) verwendet, um die Implementierung zu vereinfachen und zu automatisieren, sodass der Code klein, sauber und leicht lesbar ist: app.py (opens new window), funcs.py (opens new window).
Das Gute daran ist, dass sowohl die Eingabeaufforderungen als auch die Funktionen miteinander verbunden sind. Sie müssen also nicht über die Kombination von Eingabeaufforderung, Funktionalität und Erweiterbarkeit nachdenken. Schreiben Sie es in einem für Menschen lesbaren Format und das war's. Die GPT liest diese Dokumentation aus einer exportierten OpenAI-JSON-Datei.
Hinweis:
flask-restx generiert nur APIs im Swagger 2.0-Format. Sie müssen sie zuerst mit dem Swagger Editor (opens new window) in das OpenAPI 3.0-Format konvertieren. Sie können unsere JSON-API auf Hugging Face (opens new window) als Referenz verwenden.
# Ausführen von GPT mit Kontexten aus einer API
Mit den richtigen Anweisungen verwendet die GPT spezielle Funktionen, um verschiedene Datentypen sorgfältig zu behandeln. Beispiele für diese Datentypen sind ClickHouse SQL-Funktionen wie has(column, value) für Array-Spalten und parseDateTime32BestEffort(value) für Zeitstempelspalten.
Nachdem die richtige Abfrage an die API gesendet wurde, erstellt sie oder die API unsere Vektor-Suchabfrage mithilfe von Filtern in WHERE-Klausel-Zeichenketten. Die zurückgegebenen Werte werden als zusätzliches Wissen, das aus der Datenbank abgerufen wurde, in Zeichenketten formatiert. Wie das folgende Codebeispiel zeigt, ist diese Implementierung recht einfach.
class ArXivKnowledgeBase:
def __init__(self, embedding: SentenceTransformer) -> None:
# Dies ist unsere offene Wissensdatenbank, die default.ChatArXiv und wiki.Wikipedia enthält
self.db = clickhouse_connect.get_client(
host='msc-950b9f1f.us-east-1.aws.myscale.com',
port=443,
username='chatdata',
password='myscale_rocks'
)
self.embedding: SentenceTransformer = INSTRUCTOR('hkunlp/instructor-xl')
self.table: str = 'default.ChatArXiv'
self.embedding_col = "vector"
self.must_have_cols: List[str] = ['id', 'abstract', 'authors', 'categories', 'comment', 'title', 'pubdate']
def __call__(self, subject: str, where_str: str = None, limit: int = 5) -> Tuple[str, int]:
q_emb = self.embedding.encode(subject).tolist()
q_emb_str = ",".join(map(str, q_emb))
if where_str:
where_str = f"WHERE {where_str}"
else:
where_str = ""
# Einfach den Abfragevektor und where_str in die Abfrage einfügen
# Und Sie können es überprüfen, wenn Sie möchten
q_str = f"""
SELECT dist, {','.join(self.must_have_cols)}
FROM {self.table}
{where_str}
ORDER BY distance({self.embedding_col}, [{q_emb_str}])
AS dist ASC
LIMIT {limit}
"""
docs = [r for r in self.db.query(q_str).named_results()]
return '\n'.join([str(d) for d in docs]), len(docs)
# Fazit
GPTs sind in der Tat eine bedeutende Verbesserung der Entwicklerschnittstelle von OpenAI. Ingenieure müssen nicht zu viel Code schreiben, um ihre Chatbots zu erstellen, und Tools können jetzt eigenständig mit Eingabeaufforderungen arbeiten. Wir finden es großartig, ein Ökosystem für GPTs zu schaffen. Andererseits wird dies auch die Open-Source-Community dazu ermutigen, bestehende Möglichkeiten zur Kombination von LLMs und Tools neu zu überdenken.
Wir sind sehr aufgeregt, uns dieser neuen Herausforderung zu stellen, und wie immer suchen wir nach neuen Ansätzen, um Vektordatenbanken wie MyScale in LLMs zu integrieren. Wir sind fest davon überzeugt, dass die Einbindung einer externen Wissensdatenbank, die in einer externen Datenbank gespeichert ist, die Wahrheitsgehalt und Hilfsbereitschaft Ihres LLMs verbessern wird.
Fügen Sie MyScaleGPT (opens new window) jetzt Ihrem Konto hinzu. Oder kommen Sie zu uns auf Discord (opens new window) oder Twitter (opens new window), um eine tiefgreifende und bedeutungsvolle Diskussion über die Integration von LLM und Datenbanken zu beginnen.
