La API de Asistentes de OpenAI permite a los desarrolladores crear fácilmente asistentes de IA robustos dentro de sus aplicaciones. Esta API incluye las siguientes características/funcionalidades:

• Elimina la necesidad de manejar el historial de conversaciones,
• Proporciona acceso a herramientas alojadas por OpenAI como el Intérprete de Código y la Recuperación, y
• Mejora la llamada a funciones para herramientas de terceros.

En este artículo, veremos la API de Asistentes y cómo podemos construir una base de conocimientos personalizada utilizando bases de datos vectoriales como MyScale y vincularla a la API de Asistentes para lograr una mayor flexibilidad, precisión y ahorro de costos.

¿Qué es un Asistente de OpenAI?

Un asistente de OpenAI es un flujo de trabajo automatizado que puede aprovechar Modelos de Lenguaje Grande (LLMs), herramientas y bases de conocimientos para responder consultas de los usuarios. Y como se mencionó anteriormente, debes utilizar la API de Asistentes para crear un asistente de OpenAI.

Comencemos echando un vistazo a la API de Asistentes:

Componentes

La API de Asistentes consta de los siguientes componentes principales:

1. Asistente: Un asistente contiene la definición de las herramientas que puede utilizar, los archivos que puede leer y las indicaciones del sistema que adjuntará a los hilos creados dentro de él.
2. Hilo: Los hilos están compuestos por mensajes que controlan las conversaciones del asistente.
3. Mensajes: Los mensajes son los elementos básicos que componen un hilo y contienen todos los textos, incluidas las entradas del usuario y las respuestas generadas.
4. Ejecución: Los usuarios deben iniciar una ejecución cada vez que soliciten una respuesta del asistente. En la práctica, el asistente ejecuta todos los mensajes dentro de un hilo. El usuario debe enviar la salida de la herramienta a la ejecución si se requieren acciones.

Iniciar una Ejecución Utilizando las Herramientas de la API de Asistentes

Es una indicación de la Inteligencia Artificial porque estos asistentes saben cómo utilizar las herramientas que se les proporcionan mediante llamadas a la API. Con este fin, OpenAI ha demostrado que GPT puede convertir las solicitudes de los usuarios en herramientas de uso formateado a través de una llamada a función pasada a la API. Por lo tanto, en términos humanos, esto es equivalente a saber cómo utilizar una herramienta.

Además, estos asistentes pueden decidir cuándo y qué herramientas deben utilizarse durante la ejecución de una sola ejecución. Si simplificamos este proceso, encontraremos que:

1. Todos los mensajes dentro de un hilo se encolarán una vez que el usuario inicie la ejecución. Estos mensajes se tomarán de la cola una vez que haya recursos disponibles para procesarlos.
2. El asistente luego decidirá si utilizará alguna de las herramientas proporcionadas en la definición del asistente. Si es así, el asistente entrará en un estado de Acción Requerida - la salida de la herramienta lo bloquea hasta que se proporcione la acción requerida. Si no, el asistente devolverá inmediatamente la respuesta y marcará esta ejecución como Completada.
3. El asistente esperará la salida de las llamadas a herramientas hasta que se exceda el umbral de tiempo de espera. Si todo va según lo planeado, el asistente agregará la salida de la herramienta al hilo, devolverá la respuesta y marcará la ejecución como completada, como se describe anteriormente.

En resumen, la ejecución de una ejecución es básicamente un autómata impulsado por un LLM.

Boost Your AI App Efficiency now

Sign up for free to benefit from 150+ QPS with 5,000,000 vectors

Free Trial

Explore our product

Vinculando MyScale al Asistente de OpenAI

MyScale tiene una interfaz SQL, una ventaja significativa para las consultas automatizadas. Además, los LLM son buenos para escribir código, incluido SQL. Por lo tanto, hemos combinado los filtros SQL WHERE con una búsqueda vectorial, como se describe en nuestra documentación de llamadas a funciones (opens new window).

Ahora consideremos expandir esta llamada a función en un vínculo entre MyScale y la API de Asistentes de OpenAI.

Nunca Utilices la Herramienta de Recuperación del Asistente

OpenAI incluye una herramienta de Recuperación con la API de Asistentes que cuesta $0.2 / (GB * num_assistants) por día. Tomando el conjunto de datos de Arxiv, por ejemplo: sus datos son aproximadamente 24GB con la incrustación. Esto te costará $5 al día ($150 al mes) por solo un asistente. Además, nunca sabes cuál será el rendimiento de recuperación en términos de precisión y consumo de tiempo. Solo GPT sabe si contiene conocimientos valiosos o no. En consecuencia, una base de datos vectorial externa es imprescindible si tienes toneladas de datos para almacenar y buscar.

Definir una Base de Conocimientos como una Herramienta para un Asistente

Según la documentación oficial de la API de Asistentes, puedes crear un asistente utilizando OpenAI().beta.create_assistants.create. Aquí tienes un ejemplo si deseas construir un asistente con una base de conocimientos existente:

from openai import OpenAI
client = OpenAI()
assistant = client.beta.assistants.create(
    name="ChatData",
    instructions=(
        "You are a helpful assistant. Do your best to answer the questions. "
    ),
    tools=[
        {
            "type": "function",
            "function": {
                "name": "get_wiki_pages",
                "description": (
                    "Get some related wiki pages.\n"
                    "You should use schema here to build WHERE string:\n\n"
                    "CREATE TABLE Wikipedia (\n"
                    "    `id` String,\n"
                    "    `text` String, -- abstract of the wiki page. avoid using this column to do LIKE match\n"
                    "    `title` String, -- title of the paper\n"
                    "    `view` Float32,\n"
                    "    `url` String, -- URL to this wiki page\n"
                    "ORDER BY id\n"
                    "You should avoid using LIKE on long text columns."
                ),
                "parameters": {
                    "type": "object",
                    "properties": {
                        "subject": {"type": "string", "description": "a sentence or phrase describes the subject you want to query."},
                        "where_str": {
                            "type": "string",
                            "description": "a sql-like where string to build filter.",
                        },
                        "limit": {"type": "integer", "description": "default to 4"},
                    },
                    "required": ["subject", "where_str", "limit"],
                },
            },
        }
    ],
    model="gpt-3.5-turbo",
)

La función expuesta tiene tres entradas: subject, where_str y limit, que coinciden con la implementación del vectorstore de MyScale en LangChain (opens new window).

Como se describe en la indicación:

• subject es el texto utilizado para la búsqueda vectorial y
• where_str es el filtro estructurado escrito en formato SQL.

También agregamos el esquema de la tabla a la descripción de la herramienta, lo que ayuda al asistente a escribir filtros utilizando las funciones SQL correctas.

Inyectar Conocimiento Externo de MyScale en el Asistente

Para inyectar conocimiento externo de MyScale en nuestro asistente, necesitamos una herramienta para recuperar este conocimiento basado en los argumentos generados por el asistente. A modo de ejemplo, hemos minimizado la implementación al vectorstore de MyScale, como muestra el siguiente código:

import clickhouse_connect

db = clickhouse_connect.get_client(
    host='msc-950b9f1f.us-east-1.aws.myscale.com',
    port=443,
    username='chatdata',
    password='myscale_rocks'
)

must_have_cols = ['text', 'title', 'views']
database = 'wiki'
table = 'Wikipedia'

def get_related_pages(subject, where_str, limit):
    q_emb = emb_model.encode(subject).tolist()
    q_emb_str = ",".join(map(str, q_emb))
    if where_str:
        where_str = f"WHERE {where_str}"
    else:
        where_str = ""

    q_str = f"""
        SELECT dist, {','.join(must_have_cols)}
        FROM {database}.{table}
        {where_str}
        ORDER BY distance(emb, [{q_emb_str}]) 
            AS dist ASC
        LIMIT {limit}
        """

    docs = [r for r in db.query(q_str).named_results()]
    return '\n'.join([str(d) for d in docs])

tools = {
    "get_wiki_pages": lambda subject, where_str, limit: get_related_pages(subject, where_str, limit),
}

En segundo lugar, necesitamos un nuevo hilo para contener nuestra entrada:

thread = client.beta.threads.create()
message = client.beta.threads.messages.create(
    thread_id=thread.id,
    role="user",
    content="What is Ring in mathematics? Please query the related documents to answer this.",
)
client.beta.threads.messages.list(thread_id=thread.id)

Las ejecuciones se crean a partir de hilos y están vinculadas a un asistente específico. Diferentes ejecuciones pueden tener diferentes asistentes. Como resultado, un hilo puede contener mensajes generados utilizando diferentes herramientas.

run = client.beta.threads.runs.create(
    thread_id=thread.id,
    assistant_id=assistant.id,
    instructions= "You must use query tools to look up relevant information for every answer to a user's question.",
)

Es esencial verificar constantemente el estado de esta ejecución y proporcionar salidas para cada función que el asistente llame.

import json
from time import sleep

while True:
    run = client.beta.threads.runs.retrieve(thread_id=thread.id, run_id=run.id)
    if run.status == 'completed':
        print(client.beta.threads.messages.list(thread_id=thread.id))
        # si la ejecución está completada, entonces no necesitas hacer nada en absoluto
        break
    elif len(run.required_action.submit_tool_outputs.tool_calls) > 0:
        print("> Action Required <")
        print(run.required_action.submit_tool_outputs.tool_calls)
        # si la ejecución requiere acciones, deberás ejecutar las herramientas y enviar las salidas
        break
    sleep(1)

tool_calls = run.required_action.submit_tool_outputs.tool_calls
outputs = []

# llamando a las herramientas para cada acción requerida
for call in tool_calls:
    func = call.function
    outputs.append({"tool_call_id": call.id, "output": tools[func.name](**json.loads(func.arguments))})

if len(tool_calls) > 0:
    # enviar todas las salidas pendientes
    run = client.beta.threads.runs.submit_tool_outputs(
        thread_id=thread.id,
        run_id=run.id,
        tool_outputs=outputs
    )

Una vez que se envían las salidas, la ejecución volverá al estado en cola.

Nota: También debemos verificar constantemente el estado de esta ejecución.

from time import sleep

while client.beta.threads.runs.retrieve(
  thread_id=thread.id,
  run_id=run.id
).status != 'completed':
    print("> waiting for results... <")
    sleep(1)
messages = client.beta.threads.messages.list(thread_id=thread.id).data[0].content[0].text.value
print("> generated texts <\n\n", messages)

Finalmente, este ejemplo demuestra cómo utilizar la API de Asistentes.

Join Our Newsletter

Subscribe

Conclusión

En conclusión, la integración de la base de datos vectorial MyScale como una base de conocimientos externa con la API de Asistentes de OpenAI abre nuevas oportunidades para los desarrolladores que buscan mejorar sus asistentes de IA. Al incorporar sin problemas este valioso recurso, los desarrolladores pueden aprovechar el poder de MyScale junto con las herramientas alojadas por OpenAI como el Intérprete de Código y la Recuperación.

Esta sinergia no solo agiliza el proceso de desarrollo, sino que también dota a los asistentes de IA de una base de conocimientos más amplia, brindando a los usuarios una experiencia más sólida e inteligente. A medida que continuamos avanzando en el estudio de la Inteligencia Artificial, estas integraciones marcan un paso significativo hacia la creación de asistentes virtuales versátiles y capaces.

¡Únete a nosotros en Discord (opens new window) hoy mismo para compartir tus ideas sobre la API de Asistentes!