Con la introducción de los modelos de lenguajes grandes, el uso de estos LLM en diferentes aplicaciones ha aumentado considerablemente. En la mayoría de las aplicaciones recientes desarrolladas en muchos planteamientos de problemas, los LLM son parte de ellas.
La mayor parte del espacio de PNL, incluidos los chatbots, el análisis de sentimientos, el modelado de temas y muchos más, está siendo manejado por modelos de lenguaje grandes.
Trabajar directamente con estos LLM a menudo puede resultar difícil, lo que lleva a diferentes herramientas como LangChain y LlamaIndex, que ayudan a simplificar la creación de aplicaciones con modelos de lenguaje grandes.
En esta guía, veremos una de esas herramientas llamada Phidata, que simplifica la creación de aplicaciones del mundo real con LLM.
Objetivos principales del siguiente aprendizaje
- Comprender los conceptos básicos y el propósito de Phidata para crear aplicaciones LLM
- Aprenda a instalar Phidata y sus dependencias.
- Adquiera competencia en la creación y configuración de asistentes de LLM utilizando Phidata
- Explore la integración de varias herramientas con LLM para mejorar sus capacidades
- Desarrollar habilidades para crear resultados estructurados utilizando modelos Pydantic dentro de Phidata.
¿Qué es Phidata?
Phidata es una popular biblioteca de Python creada para crear aplicaciones del mundo real con modelos de lenguaje grandes integrándolos con memoria, conocimiento y herramientas.
Con Phidata, se puede agregar memoria a un LLM, que puede incluir el historial de Chat o podemos combinar el LLM con una Base de Conocimiento que son los almacenes de vectores, con los que podemos construir sistemas RAG (Retrieval Augmented Generation).
Finalmente, los LLM pueden incluso combinarse con herramientas, que les permiten realizar tareas que están más allá de sus capacidades.
Phidata está integrado con diferentes modelos de lenguajes grandes como OpenAI, Groq y Gemini e incluso admite modelos de lenguajes grandes de código abierto a través de Ollama.
De manera similar, admite los modelos de integración OpenAI y Gemini y otros modelos de código abierto a través de Ollama.
Actualmente, Phidata admite algunas tiendas de vectores populares como Pinecone, PGVector, Qdrant y LanceDB. Phidata incluso se integra con bibliotecas LLM populares como Langchain y LlamaIndex.
Primeros pasos con los asistentes de Phidata
En esta sección, veremos cómo descargar la biblioteca Phidata Python y comenzar con ella. Además de Phidata, necesitaremos otras bibliotecas de Python, incluidas Groq, Duckduckgo Search y OpenAI.
Para esto ejecutamos el siguiente código:
!pip install -q -U phidata groq==0.7 duckduckgo-search openai
- Phidata: esta es la biblioteca con la que trabajaremos para crear aplicaciones LLM
- groq: Groq es una empresa conocida por crear nuevos equipos GPU para ejecutar LLM más rápido. Se llama LPU (Unidad de procesamiento del lenguaje). Esta biblioteca nos permitirá acceder al modelo Mixtral que se ejecuta en las LPU (Unidad de procesamiento de lenguaje) de Groq.
- duckduckgo-search: Con esta biblioteca podemos buscar en Internet. El modelo de lenguaje grande puede aprovechar esta biblioteca para realizar búsquedas en Internet.
- openai: esta es la biblioteca oficial de OpenAI
Configuración de claves API
Entonces, ejecutar esto descargará todos los [https://cibered.com/python-modulo-solicitudes/) que queramos.
Antes de comenzar, necesitamos almacenar las API en el entorno para que Phidata pueda acceder a ellas para trabajar con los modelos subyacentes. Para ello hacemos lo siguiente.
import os
os.environ['GROQ_API_KEY'] = GROQ_API
os.environ['OPENAI_API_KEY'] = OPENAI_API_KEY
Para obtener una API gratuita desde el sitio web oficial de Groq. Con esto podemos acceder al modelo Mixtral Mixtura de Expertos. De forma predeterminada, Phidata funciona con el modelo OpenAI.
Entonces, ejecutar el código guardará la API de Groq y las claves de API de OpenAI en el entorno. Entonces, comencemos con la biblioteca Phidata.
from phi.assistant import Assistant
assistant = Assistant(
description="Eres un asistente de IA útil que responde a las consultas de todos los usuarios",
)
assistant.print_response("En resumen, ¿puedes explicar la astronomía a una niña de 7 años?", markdown=True)
Explicación del código
- Comenzamos importando la clase Assistant desde phi.assistant
- Luego, creamos una instancia de un Asistente proporcionando una descripción. Un asistente es un modelo de lenguaje grande. A este LLM, podemos proporcionar una descripción, mensajes del sistema y otras configuraciones de LLM para definir un asistente.
- Podemos llamar al LLM llamando al método .print_response(). Para esto, pasamos la consulta del usuario e incluso proporcionamos otro parámetro, markdown=True
La ejecución del código definirá un Asistente con OpenAI GPT para el LLM, luego se realizará una consulta de usuario a este modelo de lenguaje grande y finalmente, se generará el resultado.
La salida generada se formateará perfectamente. De forma predeterminada, la salida se generará en formato de transmisión.
Establecer Markdown = True es la razón por la que vemos que el resultado se imprime en un formato legible. Ahora, si deseamos cambiar el tipo de modelo OpenAI con el que queremos trabajar, podemos consultar el siguiente código.
Cambiando el modelo OpenAI
Aquí está el código:
from phi.assistant import Assistant
from phi.llm.openai import OpenAIChat
assistant = Assistant(
llm=OpenAIChat(model="gpt-3.5-turbo"),
description="Ayudas a las personas a proporcionar respuestas útiles a sus consultas",
instructions=["La lista debe contener solo 5 respuestas"],
max_tokens = 512
)
assistant.print_response("Enumere algunos de los mejores jugadores de críquet del mundo", markdown=True)
Explicación del código
- Comenzamos importando la clase Assistant desde phi.assistant, incluso importamos OpenAIChat desde phi.llm.openai
- Ahora, volvemos a crear un objeto Asistente. A esto le damos un parámetro llamado llm; Para este parámetro, proporcionamos la clase OpenAIChat() con el modelo dado. Aquí está GPT 3.5
- Aquí incluso damos algunos parámetros más como las instrucciones, a las que le pasamos las instrucciones que queremos que siga el LLM, e incluso los max_tokens, para limitar la generación del LLM.
- Finalmente, llamamos a .print_response() dándole al usuario una consulta.
La ejecución del código generará un resultado, que podemos ver a continuación. Vemos que efectivamente el modelo OpenAI ha seguido las instrucciones que le hemos dado. Produjo solo 5 elementos en la lista, lo que se alinea con las instrucciones que le dimos.
Además de OpenAI, Phidata está integrado con grandes modelos de lenguaje. Intentemos trabajar con el modelo Groq con el siguiente código.
Trabajar con el modelo Groq
Aquí está el código:
from phi.assistant import Assistant
from phi.llm.groq import Groq
assistant = Assistant(
llm=Groq(model="mixtral-8x7b-32768"),
description="Ayudas a las personas a proporcionar respuestas útiles a sus consultas",
max_tokens = 512
)
response = assistant.run('¿Cuánta altura puede volar un humano?', stream=False)
print(response)
Explicación del código
- Empezamos importando la clase Assistant desde phi.assistant, incluso importamos Groq desde phi.llm.groq
- Ahora, volvemos a crear un objeto Asistente. A esto le damos un parámetro llamado llm, y a este parámetro le proporcionamos el modelo a la clase Groq(), es decir, Mixtral Mixture of Experts.
- Incluso damos descripción y max_tokens mientras creamos el objeto Asistente.
- Aquí, en lugar de .print_response(), llamamos a la función .run(), que no imprime la salida en formato de rebajas sino en formato de cadena.
- Incluso configuramos Stream en False aquí para que podamos ver el resultado completo de una sola vez.
Ejecutar la salida producirá el resultado que podemos ver arriba. La respuesta generada por el Mixtral-8x7B parece buena. Se puede ver que la consulta del usuario no tiene sentido y proporciona la respuesta correcta a la consulta.
A veces, necesitamos que el resultado generado por el LLM siga una estructura.
Es decir, queremos que el resultado generado por el LLM esté en un formato estructurado para que sea fácil tomar este resultado y procesarlo para código futuro.
Trabajar con herramientas y crear herramientas personalizadas
Los modelos de lenguaje grandes por sí solos son muy limitados en términos de usabilidad.
Los LLM solo pueden generar texto. Pero hay casos en los que uno desea obtener las últimas noticias o obtener alguna información que requiere una llamada API. En estos escenarios, necesitaremos herramientas.
Las herramientas son armas LLM. Los LLM pueden trabajar con herramientas para realizar acciones que son imposibles de realizar con los LLM básicos.
Estas herramientas pueden ser herramientas API, donde los LLM pueden llamar a estas herramientas para realizar llamadas API y obtener información o pueden ser herramientas matemáticas, donde los LLM pueden trabajar con ellas para realizar operaciones matemáticas.
Herramientas integradas en Phidata
Phidata ya tiene algunas herramientas integradas con las que los LLM pueden trabajar. Probemos esto con el siguiente código:
from phi.assistant import Assistant
from phi.tools.duckduckgo import DuckDuckGo
assistant = Assistant(
llm=Groq(model="mixtral-8x7b-32768"),
tools=[DuckDuckGo()],
show_tool_calls=True,
description="You are a senior BBC researcher writing an article on a topic.",
max_tokens=1024
)
assistant.print_response("¿Cuál es el último LLM de Google?", markdown=True, stream = False)
Explicación del código
- Comenzamos importando la clase Asistente desde phi.assistant y, para la herramienta, importamos la herramienta DuckDuckGo desde phi.tools.duckduckgo.
- A continuación, creamos una instancia de un objeto Asistente llamando a la clase Asistente con diferentes parámetros. Estos incluyen el parámetro LLM, donde proporcionamos el modelo Groq y la descripción y los parámetros max_tokens.
- Aquí, incluso proporcionamos algunos otros parámetros como herramientas, a las que proporcionamos una lista de herramientas; aquí proporcionamos una lista con un solo elemento DuckDuckGo
- Para comprobar si el Asistente ha llamado a la herramienta o no, podemos proporcionar otro parámetro llamado show_tool_calls=True, que mostrará la llamada a la herramienta si se llama.
- Finalmente, llamamos a la función .print_response() y le dimos a un usuario una consulta pidiendo información sobre los últimos LLM de Google.
Al ejecutar este código se creará un asistente con la herramienta DuckDuckGo. Cuando llamamos al LLM con la consulta del usuario “¿Cuál es el último LLM de Google?” el LLM decidirá si realizar una llamada de función.
El resultado mostrará que el LLM ha realizado una llamada de función a la herramienta de búsqueda DuckDuckGo con la consulta “último LLM de Google”.
Los resultados obtenidos de esta llamada a función se devuelven al modelo junto con la consulta original para que el modelo pueda trabajar con estos datos y generar la respuesta final para la consulta del usuario, lo que hizo para nuestra consulta.
Ha generado la respuesta correcta sobre los últimos LLM de Google: Gemini 1.5 Flash y PaliGemma, que el equipo de Google anunció recientemente. También podemos crear nuestras herramientas integradas además de depender de las herramientas de Phidata. Un ejemplo de esto se puede ver a continuación.
Crear una herramienta personalizada
Aquí está el código:
from phi.assistant import Assistant
def power(Base: float, Exponent: float) -> str:
"Raise Base to the Exponent power"
return str(Base**Exponent)
assistant = Assistant(
llm=Groq(model="mixtral-8x7b-32768"),
tools=[power],
show_tool_calls=True)
assistant.print_response("What is 13 to the power 9.731?", stream = False)
Explicación del código
- Aquí, comenzamos importando la clase Asistente de la biblioteca Phidata.
- Luego definimos una función llamada potencia(), que toma dos números de punto flotante llamados Base y Exponente y luego devuelve la Base elevada a la potencia del exponente.
- Aquí, devolvemos la cadena porque las herramientas de Phidata esperan que la salida se devuelva en formato de cadena.
- Luego, creamos un objeto asistente y le damos a esta nueva herramienta la forma de una lista de parámetros de la herramienta junto con los demás parámetros.
- Finalmente, llamamos al asistente dándole una consulta matemática relacionada con la función
La ejecución de este código produjo el siguiente resultado. Podemos ver en el resultado que el modelo realizó una llamada de función llamando a la función de potencia y dándole los argumentos correctos tomados de la consulta del usuario. Finalmente, toma la respuesta generada por la función y luego el asistente genera la respuesta final a la pregunta del usuario. Incluso podemos asignar múltiples funciones al LLM y dejar que el asistente llame a estas funciones varias veces. Para esto, echemos un vistazo al código a continuación.
Verificación de la invocación de la herramienta
Aquí está el código:
from phi.assistant import Assistant
def power(Base: float, Exponent: float) -> str:
"Raise Base to the Exponent power"
return str(Base**Exponent)
def divison(a: float, b: float) -> str:
"Divide a by b"
return str(a/b)
assistant = Assistant(
llm=Groq(model="mixtral-8x7b-32768"),
tools=[power, divison],
show_tool_calls=True)
assistant.print_response("What is 10 power 2.83 divided by 7.3?", stream = False)
En este código, hemos definido dos funciones. La primera función toma dos flotantes llamados Base y Exponente y devuelve una cadena que contiene la Base elevada a su exponente. En comparación, la segunda función es una función de división. Dados dos números enteros, a y b, devuelve una cadena de a/b.
Luego, creamos un objeto asistente con Groq para el modelo de lenguaje grande y les damos a estas dos herramientas una lista de los parámetros de las herramientas mientras creamos el objeto asistente.
Finalmente, proporcionamos una consulta relacionada con estas herramientas para comprobar su invocación. Damos “¿Cuánto es 10 potencia 2,83 dividido por 7,3?”
En el resultado siguiente, podemos ver que se están llamando a dos herramientas. La primera es la herramienta eléctrica, a la que se llamó con los argumentos adecuados. La respuesta de las herramientas eléctricas se da en forma de argumento y otra variable al llamar a la segunda herramienta.
Finalmente, la respuesta generada por la segunda llamada a la función se entrega al LLM para que el LLM pueda generar la respuesta final.
Phidata incluso nos permite crear una aplicación cli con el Asistente. Podemos crear una aplicación de este tipo con el siguiente código.
Crear una aplicación CLI
Aquí está el código:
from phi.assistant import Assistant
from phi.tools.duckduckgo import DuckDuckGo
assistant = Assistant(tools=[DuckDuckGo()],
show_tool_calls=True,
read_chat_history=True)
assistant.cli_app(markdown=True)
- Empezamos importando el Assistant y Duckduckgo desde la biblioteca de Phidata
- Luego, creamos un objeto asistente llamando a la clase Asistente y dándole el LLM y las herramientas con las que deseamos trabajar.
- Incluso configuramos read_chat_histoy en True, lo que permitirá al modelo leer el historial de chat si es necesario.
- Finalmente, llamamos a la función .cli_app() del objeto asistente y configuramos la rebaja en Verdadero para forzar al modelo a proporcionar una respuesta de rebaja.
Al ejecutar el comando anterior se creará una aplicación de terminal donde podremos chatear con el modelo Mixtral. La conversación se puede ver en la imagen de abajo.
En la primera respuesta, Mixtral llamó a la función duckduckgo para obtener información sobre los últimos modelos creados por Google. Luego, en la segunda conversación, podemos notar que Mixtral ha invocado la función get_chat_history, la cual era necesaria dada la consulta del usuario y pudo responder la consulta del usuario correctamente.
Construyendo un equipo de asistentes
Es posible crear un equipo de asistentes a través de la biblioteca Phidata. Nos permite crear un equipo de asistentes que pueden interactuar entre sí y delegar trabajo entre sí para realizar tareas específicas con las herramientas específicas asignadas a cada asistente.
Phidata simplifica el proceso de creación de dichos asistentes. Podemos crear un equipo asistente simple con el siguiente código:
Aquí está el código
from phi.assistant import Assistant
from phi.llm.groq import Groq
def power(base: float, exponent: float) -> str:
"Raise base to the exponent power"
return str(base**exponent)
math_assistant = Assistant(
llm=Groq(model="mixtral-8x7b-32768"),
name="Math Assistant",
role="Performs mathematical operations like taking power of two numbers",
tools=[power],
)
main_assistant = Assistant(
llm=Groq(model="mixtral-8x7b-32768"),
name="Research Team",
show_tool_calls = True,
team=[math_assistant],
)
main_assistant.print_response(
"What is 5 power 9.12?",
markdown=True,
stream = False,
)
- El código comienza importando los módulos necesarios de la biblioteca Phidata: Assistant de phi.assistant, Groq de phi.llm.groq
- Luego definimos una función llamada potencia, que toma dos parámetros flotantes (Base y Exponente) y devuelve el resultado de elevar la Base al Exponente como una cadena.
- Se crea una Instancia de Asistente llamada math_assistant con atributos como el llm, donde le damos el llm con el que queremos trabajar, el nombre del asistente, aquí lo llamamos Asistente Matemático y la lista de herramientas con las que puede trabajar el asistente, proporcionar la herramienta eléctrica al asistente de matemáticas y darle un atributo de rol que defina el rol del asistente
- De manera similar, creamos un main_assistant, pero aquí le proporcionamos el atributo de equipo donde le damos una lista de asistentes a quienes puede delegar el trabajo; aquí en nuestro código, será math_assistant
- La función print_response se llama en main_assistant con una consulta (“¿Qué es 5 power 9.12?”), formateada para mostrarse en Markdown
Entonces, cuando se ejecuta el código, main_assistant recibe la consulta del usuario. La consulta contiene un problema matemático que implica tomar una potencia. Entonces, main_assistant verá esto y luego delegará el trabajo a math_assistant. Podemos ver esta llamada a función en la imagen. Ahora, math_assistant obtiene esta consulta de usuario de main_assistant y crea una llamada de función para llamar a la herramienta eléctrica con la Base y el Exponente. La respuesta devuelta por la llamada a la función luego se envía al main_assistant desde math_assistant. Finalmente, main_assistant recupera esta respuesta y crea una respuesta final a la consulta del usuario.
Conclusión
En conclusión, Phidata es una biblioteca Python sencilla y potente diseñada para simplificar la creación de aplicaciones del mundo real utilizando modelos de lenguaje grandes (LLM). Al integrar memoria, bases de conocimiento y herramientas, Phidata permite a los desarrolladores mejorar las capacidades de los LLM, que funcionan únicamente para la generación de texto sin formato.
Esta guía ha mostrado la facilidad de construir con Phidata, trabajar con diferentes tipos de LLM como OpenAI y Groq, y ampliar las funcionalidades a través de diferentes herramientas y asistentes.
La capacidad de Phidata para crear resultados estructurados, trabajar con herramientas para la recuperación de información en tiempo real y crear equipos colaborativos de asistentes la convierte en una herramienta de referencia para desarrollar aplicaciones LLM confiables y sofisticadas.