El 6 de noviembre de 2023, OpenAI anunció el lanzamiento de sus GPTs. En esta plataforma sin código, como desarrollador profesional (o aficionado), puedes construir GPTs personalizados o chatbots utilizando tus herramientas y comandos, cambiando efectivamente tus interacciones con los GPT de OpenAI. Las interacciones anteriores requerían el uso de comandos dinámicos para obtener respuestas de los GPT con LangChain (opens new window) o LlamaIndex (opens new window). Ahora, los GPT de OpenAI manejan tu comando dinámico llamando a APIs o herramientas externas.
Esto también cambia la forma en que nosotros (en MyScale) construimos sistemas RAG, pasando de construir comandos con contextos en el servidor a inyectar estos contextos en el modelo de los GPT.
MyScale simplifica la forma en que inyectas contextos en tus GPTs. Por ejemplo, el método de OpenAI es cargar archivos en la plataforma de los GPTs a través de una interfaz web. En contraste, MyScale te permite mezclar filtrado de datos estructurados y búsqueda semántica utilizando una cláusula WHERE de SQL (opens new window), procesar y almacenar una base de conocimientos mucho más grande a un costo menor, y compartir una base de conocimientos entre múltiples GPTs.
Prueba MyScaleGPT ahora 🚀 en GPT Store, o integra la base de conocimientos abierta de MyScale con tu aplicación hoy mismo con nuestra API alojada en Hugging Face:
# BYOK: Trae tu propia base de conocimientos
Los GPT han evolucionado considerablemente durante el último año y ahora conocen mucho más en el dominio del conocimiento compartido que cuando se lanzaron por primera vez. Sin embargo, todavía hay temas específicos sobre los que no saben nada o tienen incertidumbre, como el conocimiento específico de dominio y los eventos actuales. Por lo tanto, como se describe en nuestros artículos anteriores (opens new window), es obligatorio integrar una base de conocimientos externa, almacenada en MyScale, en los GPT para mejorar su veracidad y utilidad.
Cuando construimos RAG con MyScale, incorporamos un LLM a nuestra cadena (o pila). Esta vez, necesitamos llevar una base de datos de MyScale a la plataforma de los GPT. Desafortunadamente, actualmente no es posible establecer conexiones directas entre los GPT y MyScale. Por lo tanto, ajustamos la interfaz de consulta, exponiéndola como una API REST.
Debido a nuestro éxito anterior con llamadas a funciones de OpenAI (opens new window), ahora podemos diseñar una interfaz similar en la que los GPT pueden escribir consultas de búsqueda vectorial con cadenas de filtro similares a SQL. Los parámetros se escriben en OpenAPI (opens new window) de la siguiente manera:
"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
}
}
]
Con esta interfaz, los GPT pueden extraer palabras clave para describir la consulta deseada con filtros escritos en SQL.
# Proporcionando Entradas de Consulta a Diferentes Tablas
A veces es necesario consultar diferentes tablas. Esto se puede implementar utilizando entradas de API separadas. Cada entrada de API tiene su propio esquema y comandos en su documentación. Los GPT leerán la documentación de API correspondiente y escribirán las consultas correctas en la tabla correspondiente.
Es importante destacar que los métodos que presentamos anteriormente, como retrievers de autoconsulta (opens new window) y SQL vectorial (opens new window), requieren comandos dinámicos o semi-dinámicos para describir la estructura de la tabla. En cambio, los GPT funcionan como agentes conversacionales en LangChain (opens new window), donde los agentes utilizan diferentes herramientas para consultar tablas.
Por ejemplo, las entradas de API se pueden escribir en OpenAPI 3.0 de la siguiente manera:
"paths": {
// entrada de consulta a la tabla arxiv
"/get_related_arxiv": {
"get": {
// las descripciones se inyectarán en el comando de la herramienta
// para que los GPT sepan cómo y cuándo usar esta herramienta de consulta
"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": [
// parámetros mencionados anteriormente
],
}
},
// entrada de consulta a la tabla 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": [
// parámetros mencionados anteriormente
]
}
}
}
Basándonos en este fragmento de código, los GPT saben que hay dos bases de conocimientos que pueden ayudar a responder las preguntas del usuario.
Después de configurar las Acciones de los GPT para la recuperación de la base de conocimientos, simplemente llenamos las Instrucciones y le decimos a los GPT cómo consultar las bases de conocimientos y luego responder la pregunta del usuario:
Haz lo posible por responder las preguntas. Siéntete libre de utilizar cualquier herramienta disponible para buscar información relevante. Por favor, incluye todos los detalles en la consulta al llamar a las funciones de búsqueda. Al consultar utilizando las bases de conocimientos de MyScale, para un array de cadenas, utiliza
has(columna, valor a coincidir). Para la fecha de publicación, utilizaparseDateTime32BestEffort()para convertir los valores de marca de tiempo de formato de cadena en objetos de fecha y hora, NUNCA conviertas las columnas de tipo fecha y hora con esta función. Siempre debes agregar enlaces de referencia a los documentos que utilizaste.
# Alojando tu base de datos como OpenAPI
Los GPT adaptan las APIs según el estándar OpenAI 3.0. Algunas aplicaciones, como las bases de datos, no tienen interfaces OpenAPI. Por lo tanto, necesitamos utilizar un middleware para integrar los GPT con MyScale.
Hemos alojado nuestra base de datos con interfaces compatibles con OpenAI en Hugging Face (opens new window). Utilizamos flask-restx (opens new window) para simplificar y automatizar la implementación, por lo que el código es pequeño, limpio y fácil de leer: app.py (opens new window), funcs.py (opens new window).
Lo bueno de esto es que tanto los comandos como las funciones están vinculados. Por lo tanto, no necesitas pensar demasiado en la combinación de comandos, funcionalidad y extensibilidad; escríbelo en un formato legible para humanos y eso es todo. Los GPT leerán esta documentación desde un archivo JSON de OpenAI.
Nota:
flask-restx solo genera APIs en formato Swagger 2.0. Debes convertirlas a formato OpenAPI 3.0 con Swagger Editor (opens new window) primero. Puedes utilizar nuestra API JSON en Hugging Face (opens new window) como referencia.
# Ejecución de los GPT con Contextos de una API
Con las instrucciones adecuadas, los GPT utilizarán funciones especiales para manejar cuidadosamente diferentes tipos de datos. Ejemplos de estos tipos de datos incluyen funciones SQL de ClickHouse como has(columna, valor) para columnas de arrays y parseDateTime32BestEffort(valor) para columnas de marca de tiempo.
Después de enviar la consulta correcta a la API, esta o la API construirá nuestra consulta de búsqueda vectorial utilizando filtros en cadenas de cláusulas WHERE. Los valores devueltos se formatean en cadenas como conocimiento adicional recuperado de la base de datos. Como se describe en el siguiente ejemplo de código, esta implementación es bastante sencilla.
class BaseDeConocimientosArXiv:
def __init__(self, embedding: SentenceTransformer) -> None:
# Esta es nuestra base de conocimientos abierta que contiene default.ChatArXiv y wiki.Wikipedia
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 = ""
# Simplemente inyectamos el vector de consulta y where_str en la consulta
# Y puedes verificarlo si quieres
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)
# Conclusión
Los GPTs son realmente una mejora significativa para la interfaz de desarrollo de OpenAI. Los ingenieros no tienen que escribir demasiado código para construir sus chatbots, y las herramientas ahora pueden ser autosuficientes con los comandos. Creemos que es hermoso crear un ecosistema para los GPTs. Por otro lado, también fomentará a la comunidad de código abierto a repensar las formas existentes de combinar LLMs y herramientas.
Estamos muy emocionados de sumergirnos en este nuevo desafío y, como siempre, estamos buscando nuevos enfoques para integrar bases de datos vectoriales, como MyScale, con LLMs. Creemos firmemente que traer una base de conocimientos externa, almacenada en una base de datos externa, mejorará la veracidad y utilidad de tu LLM.
Agrega MyScaleGPT (opens new window) a tu cuenta ahora. O únete a nosotros en Discord (opens new window) o Twitter (opens new window) para iniciar una discusión profunda y significativa sobre la integración de LLM y bases de datos hoy mismo.
