Integra múltiples APIs de IA en una sola plataforma
Tags: ai, web, chat, docker
Published: 2024-04-19 17:22:26

# Mi Problema con OpenAi y la experiencia web
En los últimos tiempos, he estado encantado con el servicio ChatGPT Plus de OpenAI. La velocidad de respuesta de los modelos gpt-3.5-turbo y gpt-4 es realmente impresionante, y la capacidad de obtener respuestas con información actualizada de la web (con los gpts personalizados del modelo 4) ha sido de gran ayuda en mis tareas diarias.

Sin embargo, no todo ha sido perfecto. Desde el lanzamiento del modelo gpt-4, OpenAI ha limitado el número de chats que podemos tener con él a alrededor de 50 chats cada 3 horas. Esto significa que, si estás en medio de una conversación interesante con gpt-4, de repente te dirá que no puedes continuar durante 3 horas, incluso si intentas cambiar al modelo 3.5 para seguir interactuando.

Intenté utilizar el chat de Bing, el cual es gratuito y aparentemente no tiene límites de uso. Sin embargo, en realidad sí tiene límites, aunque son bastante generosos por parte de Microsoft: 30 mensajes por chat.
Quise ir un poco más allá y probar [Copilot Pro](https://www.microsoft.com/es-es/store/b/copilotpro), que cuesta aproximadamente $20 dólares al mes.

Lamentablemente, no me convenció. La interfaz es la misma que la versión gratuita, solo que sin el límite de 30 mensajes por chat. Si bien la velocidad de respuesta mejora un poco, no lo suficiente como para justificar el gasto.

Agradezco que Microsoft ofrezca esta "alternativa" a los modelos de lenguaje personalizados de OpenAI. Sin embargo, no es suficiente para mis necesidades, ya que no permite guardar mis chats anteriores con los asistentes personalizados. Esto resulta frustrante si recargo la página o cierro el chat por error.

Afortunadamente, hay varias alternativas a OpenAI, como Claude de Anthropic, Mistral.ai, Gemini de Google, Llama2 de Meta, entre otras. Estas opciones ofrecen una amplia variedad de modelos de lenguaje de última generación que pueden competir fácilmente con GPT-4 y 3.5. Sin embargo, cambiar entre diferentes chats o playgrounds no siempre resulta amigable para el usuario. Además, algunas de estas alternativas, como Claude y Mistral, no permiten cargar documentos en sus interfaces web, lo que dificulta la interacción.

![](https://i.imgur.com/kQoCor9.png)

Ya antes conocía [BetterChatGpt](https://bettergpt.chat/), una interfaz gratuita para interactuar con la API de OpenAI. Sin embargo, nuevamente no me convenció completamente debido a la falta de opciones de personalización y la ausencia de soporte para otros modelos de IA.

Fue entonces cuando surgió la idea de encontrar un lugar donde pudiera conectar todos estos servicios en un solo lugar. Gracias al poderoso y querido internet, me crucé con [Librechat](https://librechat.ai/), una plataforma que parecía ofrecer la solución que estaba buscando.

# Qué es LibreChat? 
> LibreChat es una plataforma de chat de IA gratuita y de código abierto. Esta interfaz web ofrece una gran personalización, con soporte para numerosos proveedores, servicios e integraciones de IA. Brinda un único lugar para todas las conversaciones de IA, con una interfaz familiar y mejoras innovadoras, para tantos usuarios como se necesite.
>
>  <cite>[LibreChat](https://librechat.ai/)</cite>

## IAs Soportadas
Si buscas tener todos tus servicios en un solo lugar, Librechat ofrece compatibilidad con **múltiples API**, incluyendo algunas de las más populares:

| Nombre    | Precio           | Límites y Otros Comentarios |
| --------- | ---------------- | ------------------------------------------- |
| OpenAI    | Pay as you go    | - |
| Anthropic | Pay as you go    | - |
| Gemini    | Gratis de momento| Posibles cobros en el futuro (no verificado) |
| Mistral   | Pay as you go    | - |
| OpenRouter| Ciertos Modelos Gratis / Pay as you go | - |
| Groq     | Gratis / Pay as you go | Puede tener ciertos límites en la cantidad de solicitudes |
| Ollama    | Self-Hosted      | - |                                  |

## Integrando todos los servicios con OpenRouter
Como ya sabemos, algunos de los servicios que queremos utilizar ofrecen su API de forma pública. Para acceder a ellos, necesitamos una clave de API. En este ejemplo, usaremos OpenRouter, que ofrece una amplia gama de modelos de inteligencia artificial, incluyendo algunos de los más avanzados del mercado.

Imaginemos que también queremos usar los servicios de Anthropic, Mistral, Llama2, Gemini, pero no queremos estar pagando o proporcionando los datos de nuestras tarjetas de crédito a cada uno de ellos.

La solución que OpenRouter ofrece es un servicio de proxy para las APIs de los otros proveedores. De esta forma, podemos usar OpenRouter como intermediario para acceder a los servicios de los otros proveedores sin tener que preocuparnos por los límites de uso.

OpenRouter nos ofrece modelos gratuitos con límites bastante generosos, así como modelos de pago que nos permiten hacer uso de ellos prácticamente sin restricciones. Esto nos brinda flexibilidad y control sobre los recursos que utilizamos, sin tener que lidiar directamente con las políticas y limitaciones de cada proveedor por separado.

![](https://i.imgur.com/CKuzJgc.png)

## Primero lo primero, obtener nuestra clave de OpenRouter
Nos vamos a dirigir al sitio de [OpenRouter](https://openrouter.ai/) y nos registraremos de forma gratuita. Si te acomoda usar tu cuenta de Google, puedes hacerlo.
Una vez con nuestra cuenta creada, vamos a la sección de [Key](https://openrouter.ai/keys) y le damos en **Create Key**

![](https://i.imgur.com/mC6m2TL.png)

Podemos asignar un nombre y la cantidad de créditos que queremos destinar a cada servicio. Los créditos están en dólares, por lo que es importante tener cuidado con la cantidad que asignamos.

Si no quieres gastar nada y deseas utilizar únicamente los modelos gratuitos, puedes asignarle 1 crédito o dejar el campo en blanco. Sin embargo, te recomiendo asignar 1 crédito, ya que dejar el campo en blanco significa que el servicio podrá utilizar créditos de forma ilimitada, lo cual podría generar costos inesperados.

De esta manera, puedes tener un control más preciso sobre los recursos que asignas a cada servicio, evitando gastos excesivos y manteniendo el uso de los modelos gratuitos cuando sea apropiado.

![](https://i.imgur.com/aXXwJWO.png)

Una vez nos retorne nuestra key, debemos guardarla en un lugar seguro. No la compartas con nadie, ya que con ella podrán hacer uso de tus creditos. Además que una vez cerrada la ventana, **no podrás verla de nuevo.**
No te preocupes si no tienes créditos, podrás usar los modelos gratuitos sin problemas.

¡Listo!, ya tenemos nuestra key. El siguiente paso, es instalar ¡¡LibreChat!!

# Instalando LibreChat 🎊
Este paso puede ser un poco más avanzado. Si no te sientes cómodo usando Linux y Docker, o no tienes un servidor donde instalarlo, puedes optar por las alternativas de implementación que se ofrecen en el [repositorio de LibreChat](https://github.com/danny-avila/LibreChat/blob/main/README.md).

Estas opciones te permiten desplegar LibreChat sin necesidad de configurar un entorno Linux y Docker por tu cuenta. Esto puede ser especialmente útil si tienes experiencia limitada en estos ámbitos o si simplemente prefieres una solución más sencilla y lista para usar.

Revisa las diferentes alternativas disponibles en el repositorio y elige la que mejor se adapte a tus necesidades y nivel de experiencia. Esto te permitirá disfrutar de los beneficios de LibreChat sin tener que lidiar con los detalles técnicos más complejos.

## Requerimientos
- Docker 
- Docker Compose
- Linux (o WSL en Windows)
- Git

Para nuestro caso, vamos a instalar LibreChat en una maquina virtual Linux con Docker bajo WSL 2. Si no sabes qué es WSL, te recomiendo leer [este artículo](https://learn.microsoft.com/es-es/windows/wsl/about).
En la actualidad instalar WSL es tan sencillo como ir a la Store de Microsoft y buscar WSL o Ubuntu. El resto del proceso es bastante intuitivo y automático.

> Si no tienes WSL y usas directamente Linux, puedes continuar directamente con la instalación de Docker.

## Instalamos Docker y Git
Una vez tengas WSL instalado, abre una terminal y ejecuta los siguientes comandos:

```bash
sudo apt-get update
sudo apt-get install git -y

# Add Docker's official GPG key:
sudo apt-get install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

# Add the repository to Apt sources:
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y
```

Seguimos los pasos post-instalación de Docker:

```bash
sudo groupadd docker
sudo usermod -aG docker $USER
newgrp docker
```

Y verificamos que todo está ok con:

```bash
docker run hello-world
```

## Instalamos Docker Compose (Opcional)
Actualmente, no es necesario instalar Docker Compose por separado, ya que viene incluido en la instalación de Docker. Sin embargo, si deseas instalarlo de forma independiente, puedes hacerlo utilizando los siguientes comandos:

```bash
sudo apt install docker-compose -y
```

Cabe mencionar que este proceso nos instalará una versión antigua de Docker Compose, la cual se ejecuta con el comando `docker-compose`. En contraste, la versión más reciente se ejecuta utilizando el comando `docker compose`.

## Creando Nuestro entorno para LibreChat
Una vez que todo esté funcionando y hayamos confirmado que Docker está instalado, procederemos a obtener nuestro archivo `docker-compose.yml` desde el repositorio de LibreChat.

```bash
git clone https://github.com/danny-avila/LibreChat.git
cd LibreChat
```

Ahora, crearemos nuestro archivo `.env` con las variables de entorno necesarias para LibreChat.

```bash
cp .env.example .env
```

Una vez que tengamos nuestro archivo `.env` creado, procederemos a levantar nuestros contenedores con el siguiente comando:

```bash
docker compose up -d
``` 

Obteniendo un resultado similar a:

```log
❯ docker compose up -d
WARN[0000] The "UID" variable is not set. Defaulting to a blank string.
WARN[0000] The "GID" variable is not set. Defaulting to a blank string.
WARN[0000] The "UID" variable is not set. Defaulting to a blank string.
WARN[0000] The "GID" variable is not set. Defaulting to a blank string.
WARN[0000] The "UID" variable is not set. Defaulting to a blank string.
WARN[0000] The "GID" variable is not set. Defaulting to a blank string.
WARN[0000] /home/alvarosdev/Repos/LibreChat/docker-compose.yml: `version` is obsolete
[+] Running 64/35
 ✔ rag_api Pulled                                                                                                                  26.9s
 ✔ mongodb Pulled                                                                                                                  30.0s
 ✔ meilisearch Pulled                                                                                                              23.9s
 ✔ api Pulled                                                                                                                      37.9s
 ✔ vectordb Pulled

 [+] Running 7/7
 ✔ Network librechat_default       Created                                                                                          0.1s
 ✔ Volume "librechat_pgdata2"      Created                                                                                          0.0s
 ✔ Container librechat-vectordb-1  Started                                                                                          0.6s
 ✔ Container chat-mongodb          Started                                                                                          0.6s
 ✔ Container chat-meilisearch      Started                                                                                          0.6s
 ✔ Container librechat-rag_api-1   Started                                                                                          0.0s
 ✔ Container LibreChat             Started                                                                                          0.0s
```

¡Excelente! Hemos completado un paso más en nuestro proceso de experimentación/instalación.

## Configurando LibreChat
LibreChat se está ejecutando en nuestro contenedor de Docker y está listo para que nos registremos. Para ello, abriremos nuestro navegador y accederemos a la dirección [http://localhost:3080/login](http://localhost:3080/login).

Procederemos a registrar una cuenta utilizando el correo electrónico que deseemos y una contraseña segura. Una vez completado este paso, se iniciará sesión de forma automática.

![](https://i.imgur.com/lZEUMhf.png)

![](https://i.imgur.com/HXqrtjl.png)

## Activando OpenRouter
Recordarás que en los pasos anteriores guardamos la clave de OpenRouter. Ahora es el momento de utilizarla. Si revisas detenidamente la interfaz de LibreChat, no verás OpenRouter por ningún lado. Esto se debe a que debemos activarlo en nuestras variables de entorno.

![](https://i.imgur.com/08UW1K7.png)

### Editamos nuestro .env
Recordarás que anteriormente también hicimos una copia de nuestro archivo `.env.example` y la renombramos como `.env`. Ahora es el momento de editar este archivo e incluir nuestra clave de OpenRouter.

En la línea `69` de nuestro archivo `.env`, agregaremos nuestra clave de OpenRouter, asegurándote de eliminar el carácter `#` al inicio de la línea.

```env
# SHUTTLEAI_KEY=
OPENROUTER_KEY=sk-or-v1-707...d5f	<---- aquí va nuestra key
# MISTRAL_API_KEY=
```

En la linea `58` de nuestro archivo, vamos a agregar `OpenRouter` al final de la lista, y vamos a quitar el `#` al inicio de la linea.

```env
ENDPOINTS=openAI,assistants,azureOpenAI,bingAI,google,gptPlugins,anthropic,OpenRouter	<---- aquí agregamos OpenRouter
```

Luego, vamos a modificar nuestro archivo `librechat.yaml`, el cual debemos obtener de `librechat.yaml.example`:

```bash
cp librechat.yaml.example librechat.yaml
```

Abriremos nuestro archivo `docker-compose.yml` y, en la línea `30`, realizaremos las siguientes modificaciones:

```yaml
volumes:
	- type: bind
		source: ./.env
		target: /app/.env
	- ./images:/app/client/public/images
	- ./logs:/app/api/logs
	- ./librechat.yaml:/app/librechat.yaml # <---- Agregamos esta linea
```

Ahora, accederemos a la URL [http://localhost:3080/login](http://localhost:3080/login) y veremos que OpenRouter ya está disponible para su uso.

![](https://i.imgur.com/WBSOskM.png)

> Dato importante: Si agregamos nuestra clave en la variable de entorno `OPENROUTER_API_KEY`, no será necesario modificar los archivos `librechat.yaml` ni `docker-compose.yml`. Sin embargo, en este caso, no podremos utilizar los modelos de OpenAI si lo deseáramos.

Si observamos detenidamente, también se han activado los endpoints de Mistral y Groq. Si deseamos utilizarlos, solo debemos agregar las claves correspondientes en el archivo `.env`, de la misma manera que lo hicimos con OpenRouter.

## Usando los modelos grátis de OpenRouter
¿Te has fijado en algo interesante? Tenemos a nuestra disposición una cantidad impresionante de modelos, varios de los cuales son gratuitos. Si no tienes créditos en OpenRouter, puedes utilizar estos modelos sin problemas. Siempre y cuando no abusemos de ellos, no deberíamos enfrentar inconvenientes.

Podemos encontrar los modelos gratuitos con el sufijo `:free` en la lista de modelos disponibles. 

![](https://i.imgur.com/d5Gov0a.png)

Hagamos una pequeña prueba. Utilizaremos el modelo `google/gemma-7b-it:free`, el cual es un modelo de lenguaje de Google similar a GPT-3. En el menú superior, al lado del nombre de OpenRouter, seleccionaremos `google/gemma-7b-it:free` y escribiremos algo como "Hola, ¿cómo estás?".

![](https://i.imgur.com/HjofqVn.png)

Ahora vamos a cambiar de modelo, sin perder el contexto de la conversación. Seleccionamos `mistralai/mistral-7b-instruct:free` y luego escribimos algo como `¿Qué es un perro?`.

![](https://i.imgur.com/ITAptVh.png)

Notaremos que gran parte de los modelos gratuitos a veces pueden generar respuestas extrañas, pero en general son bastante buenos. Si deseamos utilizar los modelos de pago, deberemos tener créditos en nuestra cuenta de OpenRouter.

Para ejemplificar, utilizaremos uno de los modelos de pago más esperados de Google, `google/gemini-pro-1.5`. Si seleccionamos este modelo, veremos que nos solicitará créditos para poder usarlo.

![](https://i.imgur.com/fa7ue0W.png)

## Bonus: Chateando con nuestros PDFs
Un dato interesante y no menos importante es que podemos interactuar con nuestros documentos, como PDFs e imágenes, a través de LibreChat. Para ello, simplemente deberemos arrastrar y soltar el archivo en la interfaz de LibreChat.

Voy a utilizar un documento de prueba que he encontrado en [este enlace](https://obtienearchivo.bcn.cl/obtienearchivo?id=repositorio/10221/28751/1/BCN_Neutralidad_de_la_Red_y_zero_rating_edPM.pdf).

Lamentablemente, para que LibreChat pueda procesar nuestros documentos, será necesario contar con una clave de OpenAI 😢 (que incluya créditos). Sin embargo, esto nos brindará la ventaja de poder utilizar casi cualquier modelo para analizar nuestros documentos.

![](https://i.imgur.com/AotdnpG.png)

A diferencia de los modelos de texto, con los modelos compatibles con visión, como Claude3, Gemini Pro 1.5, GPT4V, entre otros, podremos analizar imágenes sin problemas y sin necesidad de contar con una clave de OpenAI.

![](https://i.imgur.com/kRmzGXs.png)

# Eso es todo...(?)
Mi experiencia con LibreChat ha sido realmente satisfactoria. Después de lidiar con las limitaciones y problemas que enfrentaba con servicios como OpenAI y Bing, encontré en LibreChat la solución que estaba buscando.

La interfaz es realmente amigable y personalizable. Puedo cambiar fácilmente entre diferentes modelos de IA sin perder el contexto de la conversación, lo cual ha sido un gran alivio.

En general, LibreChat ha sido la solución que necesitaba para gestionar de manera centralizada y eficiente mis interacciones con múltiples asistentes de IA. Estoy realmente satisfecho con los resultados y lo recomiendo encarecidamente a cualquiera que esté buscando una plataforma integral y conveniente para sus necesidades de IA.

# Un dato algo offtopic
El modelo Mistral8x7b, siendo muy ligero y "económico", me ha sorprendido gratamente por su velocidad de respuesta y su capacidad para generar código e interpretar documentos sin consumir tantos tokens.

Por otro lado, los modelos de Anthropic, Claude 3 en sus versiones Haiku, Sonnet y Opus, son simplemente impresionantes. Estos tres modelos tienen la habilidad de generar texto de alta calidad, interpretar documentos con una precisión bastante interesante, e incluso comprender imágenes. ¡Incluso han logrado entender memes! 😂

![](https://i.imgur.com/eFwH51G.png)