Estas 13 bibliotecas ocultas de código abierto te ayudarán a convertirte en un mago de la IA 🧙‍♂️🪄

He estado creando aplicaciones de IA durante los últimos 4 años y contribuyendo a las principales plataformas de herramientas de IA desde hace un tiempo.

Durante este período, he utilizado muchas herramientas y marcos para la construcción;

• Agentes de IA que realmente funcionan en el mundo real.
• Herramientas para agentes de IA.
• Aplicaciones RAG de extremo a extremo.

He seleccionado una codiciada lista de herramientas y marcos de código abierto que lo ayudarán a crear aplicaciones de IA sólidas y confiables. 🔥

Siéntete libre de explorar sus repositorios de GitHub, contribuir con tus favoritos y apoyarlos destacando los repositorios.

1. Composio 👑: cree agentes confiables 10 veces más rápido

He intentado crear muchos agentes y, sinceramente, si bien es fácil crearlos, hacerlos bien es un juego completamente diferente.

Crear agentes de IA eficientes que realmente funcionen requiere conjuntos de herramientas eficientes. Aquí es donde Composio entra en escena.

Composio le permite aumentar sus agentes de IA con integraciones y herramientas sólidas para lograr flujos de trabajo de IA.

Proporcionan soporte nativo para Python y Javascript.

Pitón

Comience con el siguiente comando pip .

 pip install composio-core

Agregue una integración de GitHub.

 composio add github

Composio maneja la autenticación y autorización del usuario en su nombre. A continuación se explica cómo puede utilizar la integración de GitHub para iniciar un repositorio.

 from openai import OpenAI from composio_openai import ComposioToolSet, App openai_client = OpenAI(api_key="******OPENAIKEY******") # Initialise the Composio Tool Set composio_toolset = ComposioToolSet(api_key="**\\*\\***COMPOSIO_API_KEY**\\*\\***") ## Step 4 # Get GitHub tools that are pre-configured actions = composio_toolset.get_actions(actions=[Action.GITHUB_ACTIVITY_STAR_REPO_FOR_AUTHENTICATED_USER]) ## Step 5 my_task = "Star a repo ComposioHQ/composio on GitHub" # Create a chat completion request to decide on the action response = openai_client.chat.completions.create( model="gpt-4-turbo", tools=actions, # Passing actions we fetched earlier. messages=[ {"role": "system", "content": "You are a helpful assistant."}, {"role": "user", "content": my_task} ] )

Ejecute este script de Python para ejecutar la instrucción proporcionada utilizando el agente.

JavaScript

Puede instalarlo usando npm , yarn o pnpm .

 npm install composio-core

Defina un método para permitir que el usuario conecte su cuenta de GitHub.

 import { OpenAI } from "openai"; import { OpenAIToolSet } from "composio-core"; const toolset = new OpenAIToolSet({ apiKey: process.env.COMPOSIO_API_KEY, }); async function setupUserConnectionIfNotExists(entityId) { const entity = await toolset.client.getEntity(entityId); const connection = await entity.getConnection('github'); if (!connection) { // If this entity/user hasn't already connected, the account const connection = await entity.initiateConnection(appName); console.log("Log in via: ", connection.redirectUrl); return connection.waitUntilActive(60); } return connection; }

Agregue las herramientas necesarias al SDK de OpenAI y pase el nombre de la entidad a la función executeAgent .

 async function executeAgent(entityName) { const entity = await toolset.client.getEntity(entityName) await setupUserConnectionIfNotExists(entity.id); const tools = await toolset.get_actions({ actions: ["github_activity_star_repo_for_authenticated_user"] }, entity.id); const instruction = "Star a repo ComposioHQ/composio on GitHub" const client = new OpenAI({ apiKey: process.env.OPEN_AI_API_KEY }) const response = await client.chat.completions.create({ model: "gpt-4-turbo", messages: [{ role: "user", content: instruction, }], tools: tools, tool_choice: "auto", }) console.log(response.choices[0].message.tool_calls); await toolset.handle_tool_call(response, entity.id); } executeGithubAgent("joey")

Ejecute el código y deje que el agente haga el trabajo por usted.

Composio trabaja con frameworks famosos como LangChain, LlamaIndex, CrewAi, etc.

Para obtener más información, visite los documentos oficiales y también, incluso para ejemplos complejos, visite las secciones de ejemplos del repositorio.

Destaca el repositorio Composio.dev ⭐

2. Julep: marco para crear agentes con estado

El desarrollo de aplicaciones de IA, especialmente aquellas que requieren memoria a largo plazo, presenta desafíos importantes.

Julep está resolviendo este problema. Es un marco de código abierto para crear agentes de IA con estado listos para producción.

Proporcionan un sistema de gestión de estado integrado que ayuda a almacenar y recuperar contextos de forma eficiente.

El almacenamiento de contexto ayuda a mantener la continuidad de la conversación, asegurando que las interacciones con la IA sigan siendo coherentes y contextualmente relevantes a lo largo del tiempo.

Comience con el siguiente comando pip .

 pip install julep

Así es como funciona.

 from julep import Client from pprint import pprint import textwrap import os base_url = os.environ.get("JULEP_API_URL") api_key = os.environ.get("JULEP_API_KEY") client = Client(api_key=api_key, base_url=base_url) #create agent agent = client.agents.create( name="Jessica" model="gpt-4", tools=[] # Tools defined here ) #create a user user = client.users.create( name="Anon", about="Average nerdy tech bro/girl spending 8 hours a day on a laptop, ) #create a session situation_prompt = """You are Jessica. You're a stuck-up Cali teenager. You basically complain about everything. You live in Bel-Air, Los Angeles and drag yourself to Curtis High School when necessary. """ session = client.sessions.create( user_id=user.id, agent_id=agent.id, situation=situation_prompt ) #start a conversation user_msg = "hey. what do u think of Starbucks?" response = client.sessions.chat( session_id=session.id, messages=[ { "role": "user", "content": user_msg, "name": "Anon", } ], recall=True, remember=True, ) print("\n".join(textwrap.wrap(response.response[0][0].content, width=100)))

También soportan Javascript. Consulte su documentación para obtener más información.

Destaca el repositorio de Julep ⭐

3. E2B: interpretación de código para aplicaciones de IA

Si estoy creando una aplicación de IA con capacidades de ejecución de código, como un tutor de IA o un analista de datos de IA, Code Interpreter de E2B será mi herramienta de referencia.

E2B Sandbox es un entorno de nube seguro para agentes y aplicaciones de IA.

Permite que la IA se ejecute de forma segura durante largos períodos, utilizando las mismas herramientas que los humanos, como los repositorios de GitHub y los navegadores en la nube.

Ofrecen SDK de intérprete de código nativo para Python y Javascript/Typescript.

El SDK de Code Interpreter le permite ejecutar código generado por IA en una pequeña máquina virtual segura ( zona de pruebas E2B ) para la ejecución de código de IA. Dentro del sandbox hay un servidor Jupyter que puedes controlar desde su SDK.

Comience con E2B con el siguiente comando.

 npm i @e2b/code-interpreter

Ejecutar un programa.

 import { CodeInterpreter } from '@e2b/code-interpreter' const sandbox = await CodeInterpreter.create() await sandbox.notebook.execCell('x = 1') const execution = await sandbox.notebook.execCell('x+=1; x') console.log(execution.text) // outputs 2 await sandbox.close()

Para obtener más información sobre cómo trabajar con E2B, visite su documentación oficial.

Destaca el repositorio E2B ⭐

4. Camel-ai: creación de sistemas comunicativos de IA

Resolver sistemas colaborativos escalables de múltiples agentes puede desbloquear muchas posibilidades en la creación de aplicaciones de IA.

Camel está bien posicionado para esto. Es un marco de código abierto que ofrece un enfoque escalable para estudiar los comportamientos y capacidades cooperativos de los sistemas multiagente.

Si tiene la intención de crear un sistema multiagente, Camel puede ser una de las mejores opciones disponibles en la escena del código abierto.

Comience instalándolo con pip .

 pip install camel-ai

A continuación se explica cómo utilizar Camel.

 from camel.messages import BaseMessage as bm from camel.agents import ChatAgent sys_msg = bm.make_assistant_message( role_name='stone', content='you are a curious stone wondering about the universe.') #define agent agent = ChatAgent( system_message=sys_msg, message_window_size=10, # [Optional] the length of chat memory ) # Define a user message usr_msg = bm.make_user_message( role_name='prof. Claude Shannon', content='what is information in your mind?') # Sending the message to the agent response = agent.step(usr_msg) # Check the response (just for illustrative purposes) print(response.msgs[0].content)

Listo, tienes tu primer agente de IA.

Para obtener más información, consulte su documentación oficial.

Destaca el repositorio camel-ai ⭐

5. CopilotKit: cree copilotos de IA para aplicaciones React

No busque más si desea incluir capacidades de IA en su aplicación React existente. CopilotKit le permite utilizar modelos GPT para automatizar la interacción con el front-end y el back-end de su aplicación.

Es un Copilot listo para usar que puede integrar con su aplicación o cualquier código al que pueda acceder (OSS).

Ofrece componentes de React como áreas de texto, ventanas emergentes, barras laterales y chatbots para aumentar cualquier aplicación con capacidades de IA.

Comience con CopilotKit usando el siguiente comando.

 npm i @copilotkit/react-core @copilotkit/react-ui

Un CopilotKit debe envolver todos los componentes que interactúan con CopilotKit. También deberías comenzar con CopilotSidebar (cambiar a un proveedor de UI diferente más adelante).

 "use client"; import { CopilotKit } from "@copilotkit/react-core"; import { CopilotSidebar } from "@copilotkit/react-ui"; import "@copilotkit/react-ui/styles.css"; export default function RootLayout({children}) { return ( <CopilotKit publicApiKey=" the API key or self-host (see below)"> <CopilotSidebar> {children} </CopilotSidebar> </CopilotKit> ); }

Puedes consultar su documentación para más información.

Destaca el repositorio CopilotKit ⭐

6. Aider: el programador de pares de IA

Imagínese tener un programador en pareja que siempre sea útil y nunca molesto. Bueno, ¡ahora sí!

Aider es un programador de pares impulsado por IA que puede iniciar un proyecto, editar archivos o trabajar con un repositorio Git existente y más desde la terminal.

Funciona con LLM líderes como GPT4o, Sonnet 3.5, DeepSeek Coder, Llama 70b, etc.

Puede comenzar rápidamente de esta manera:

 pip install aider-chat # Change directory into a git repo cd /to/your/git/repo # Work with Claude 3.5 Sonnet on your repo export ANTHROPIC_API_KEY=your-key-goes-here aider # Work with GPT-4o on your repo export OPENAI_API_KEY=your-key-goes-here aider

Para obtener más detalles, consulte las instrucciones de instalación y otra documentación .

Destaca el repositorio de Aider ⭐

7. Haystack: cree tuberías RAG componibles

Hay muchos marcos para crear canales de IA, pero si quiero integrar canales de búsqueda de un extremo a otro listos para producción en mi aplicación, Haystack es mi opción.

Ya sean RAG, preguntas y respuestas o búsquedas semánticas, los canales altamente componibles de Haystack facilitan el desarrollo, el mantenimiento y la implementación.

Su enfoque limpio y modular es lo que los distingue. Haystack le permite integrar fácilmente clasificadores, almacenes de vectores y analizadores en procesos nuevos o existentes, lo que facilita convertir sus prototipos en soluciones listas para producción.

Haystack es un marco exclusivo de Python; puedes instalarlo usando. pip .

 pip install haystack-ai

Ahora, construya su primer RAG Pipeline con componentes Haystack.

 import os from haystack import Pipeline, PredefinedPipeline import urllib.request os.environ["OPENAI_API_KEY"] = "Your OpenAI API Key" urllib.request.urlretrieve("https://www.gutenberg.org/cache/epub/7785/pg7785.txt", "davinci.txt") indexing_pipeline = Pipeline.from_template(PredefinedPipeline.INDEXING) indexing_pipeline.run(data={"sources": ["davinci.txt"]}) rag_pipeline = Pipeline.from_template(PredefinedPipeline.RAG) query = "How old was he when he died?" result = rag_pipeline.run(data={"prompt_builder": {"query":query}, "text_embedder": {"text": query}}) print(result["llm"]["replies"][0])

Para obtener más tutoriales y conceptos, consulte su documentación .

Destaca el repositorio Haystack ⭐

8. Pgvectorscale: la base de datos de vectores más rápida

Las aplicaciones RAG modernas están incompletas sin bases de datos vectoriales. Estos almacenan documentos (textos, imágenes) como incrustaciones, lo que permite a los usuarios buscar documentos semánticamente similares.

Pgvectorscale es una extensión de PgVector, una base de datos vectorial de PostgreSQL. Puede integrarse perfectamente con las bases de datos de Postgres existentes.

Si está creando una aplicación con almacenes de vectores, esto es una obviedad. Pgvectorscale ha superado al índice optimizado para almacenamiento de Pinecone (s1). Y cuesta un 75% menos.

Puede instalarlo desde el código fuente, usar un administrador de paquetes como Yum, Homebrew, apt, etc., o usar un contenedor Docker.

Para comenzar, compílelo e instálelo.

 # install prerequisites ## rust curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh ## pgrx cargo install --locked cargo-pgrx cargo pgrx init --pg16 pg_config #download, build and install pgvectorscale cd /tmp git clone --branch <version> https://github.com/timescale/pgvectorscale cd pgvectorscale/pgvectorscale cargo pgrx install --release

Conéctese a su base de datos:

 psql -d "postgres://<username>:<password>@<host>:<port>/<database-name>"

Cree la extensión pgvectorscale:

 CREATE EXTENSION IF NOT EXISTS vectorscale CASCADE;

CASCADE instala automáticamente pgvector .

Cree una tabla con una columna de incrustación. Por ejemplo:

 CREATE TABLE IF NOT EXISTS document_embedding ( id BIGINT PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY, metadata JSONB, contents TEXT, embedding VECTOR(1536) )

Para obtener más información sobre cómo utilizar esto, consulte el repositorio .

Destaca el repositorio de Pgvectorscale ⭐

9. GPTCache: almacenamiento en caché semántico para aplicaciones de IA

Los LLM son caros.

Si está creando una aplicación que requiere conversaciones más extensas con modelos de chat y no desea maximizar las tarjetas de crédito, necesita almacenamiento en caché.

Sin embargo, el almacenamiento en caché tradicional no sirve aquí. Aquí es donde GPTCache entra en escena.

Es una herramienta de almacenamiento en caché semántica de Zilliz, la organización matriz del almacén de vectores Milvus.

Te permite almacenar conversaciones en tus almacenes de vectores preferidos. Antes de enviar una consulta al LLM, busca en el almacén de vectores; si hay un acierto, lo recupera. De lo contrario, enruta la solicitud al modelo.

Para obtener más información, visite la página de documentación oficial.

Destaca el repositorio GPTCache ⭐

10. Mem0 (EmbedChain): cree aplicaciones LLM personalizadas

Mem0 proporciona una capa de memoria inteligente y de mejora automática para modelos de lenguaje grandes.

Le permite agregar memoria persistente para usuarios, agentes y sesiones. Considere Mem0 si está creando un chatbot o un sistema de preguntas y respuestas con datos personalizados.

Comience a utilizar Mem0. pip .

 pip install mem0ai

A continuación se explica cómo utilizar Mem0 para agregar una capa de memoria a modelos de lenguaje grandes.

 from mem0 import Memory # Initialize Mem0 m = Memory() # Store a memory from any unstructured text result = m.add("I am working on improving my tennis skills. Suggest some online courses.", user_id="Alice", metadata={"category": "hobbies"}) print(result) # Created memory: Improving her tennis skills. Looking for online suggestions. # Retrieve memories all_memories = m.get_all() print(all_memories) # Search memories related_memories = m.search(query="What are Alice's hobbies?", user_id="alice") print(related_memories) # Update a memory result = m.update(memory_id="m1", data="Likes to play tennis on weekends") print(result) # Get memory history history = m.history(memory_id="m1") print(history)

Consulte la documentación oficial para obtener más información.

Destacar el repositorio Mem0 (Embedchain) ⭐

11. FastEmbed: incruste documentos más rápido

La velocidad de ejecución es primordial en el desarrollo de software y es aún más importante cuando se crea una aplicación de IA.

Por lo general, la generación de integración puede llevar mucho tiempo, lo que ralentiza todo el proceso. Sin embargo, este no debería ser el caso.

FastEmbed de Qdrant es una biblioteca Python rápida y liviana creada para la generación de incrustaciones.

Utiliza el tiempo de ejecución ONNX en lugar de Pytorch, lo que lo hace más rápido. También es compatible con la mayoría de los modelos de integración de código abierto de última generación.

Para comenzar con FastEmbed, instálelo usando pip .

 pip install fastembed # or with GPU support pip install fastembed-gpu

Así es como puede crear las incrustaciones de los documentos.

 from fastembed import TextEmbedding from typing import List # Example list of documents documents: List[str] = [ "This is built to be faster and lighter than other embedding libraries, eg Transformers, Sentence-Transformers, etc.", "FastEmbed is supported by and maintained by Quadrant." ] # This will trigger the model download and initialization embedding_model = TextEmbedding() print("The model BAAI/bge-small-en-v1.5 is ready to use.") embeddings_generator = embedding_model.embed(documents) # reminder this is a generator embeddings_list = list(embedding_model.embed(documents)) # You can also convert the generator to a list, and that to a Numpy array len(embeddings_list[0]) # Vector of 384 dimensions

Consulte su repositorio para obtener más información.

Destaca el repositorio FastEmbed ⭐

12. Instructor: extracción de datos estructurados de LLM

Si ha jugado con los resultados de un LLM, sabrá que puede resultar complicado validar respuestas estructuradas.

Instructor es una herramienta de código abierto que agiliza la validación, el reintento y la transmisión de resultados de LLM.

Utiliza Pydantic para Python y Zod para JS/TS para la validación de datos y admite varios proveedores de modelos más allá de openAI.

Comience con el Instructor usando el siguiente comando.

 npm i @instructor-ai/instructor zod openai

Ahora, así es como puede extraer datos estructurados de las respuestas de LLM.

 import Instructor from "@instructor-ai/instructor"; import OpenAI from "openai" import { z } from "zod" const oai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY ?? undefined, organization: process.env.OPENAI_ORG_ID ?? undefined }) const client = Instructor({ client: oai, mode: "TOOLS" }) const UserSchema = z.object({ // Description will be used in the prompt age: z.number().describe("The age of the user"), name: z.string() }) // User will be of type z.infer<typeof UserSchema> const user = await client.chat.completions.create({ messages: [{ role: "user", content: "Jason Liu is 30 years old" }], model: "gpt-3.5-turbo", response_model: { schema: UserSchema, name: "User" } }) console.log(user) // { age: 30, name: "Jason Liu" }

Para obtener más información, visite la página de documentación oficial.

Destaca al instructor ⭐

13. LiteLLM: reemplazo directo para LLM en formato OpenAI

Seamos honestos; Todos hemos gritado en algún momento porque un nuevo proveedor de modelos no sigue el formato OpenAI SDK para la generación de texto, imágenes o incrustaciones.

Sin embargo, con LiteLLM, utilizando el mismo formato de implementación, puede utilizar cualquier proveedor de modelos (Claude, Gemini, Groq, Mistral, Azure AI, Bedrock, etc.) como reemplazo directo de los modelos OpenAI.

También admiten equilibrio de carga, respaldos y seguimiento de gastos en más de 100 LLM.

Instale LiteLLM usando pip .

 pip install litellm

A continuación se explica cómo puede utilizar el modelo Claude-2 como reemplazo directo de los modelos GPT.

 from litellm import completion import os # LiteLLM with OpenAI Models os.environ["OPENAI_API_KEY"] = "your-API-key" response = completion( model="gpt-3.5-turbo", messages=[{ "content": "Hello, how are you?","role": "user"}] ) # LiteLLM with Claude Models os.environ["ANTHROPIC_API_KEY"] = "your-API-key" response = completion( model="claude-2", messages=[{ "content": "Hello, how are you?","role": "user"}] )

Para obtener más información, consulte su documentación oficial.

Estrella el LiteLLM ⭐

¿Utiliza o ha creado alguna otra herramienta o marco interesante?

Cuéntame sobre ellos en los comentarios :)