Ces 13 bibliothèques open source cachées vous aideront à devenir un assistant d'IA 🧙‍♂️🪄

Je crée des applications d'IA depuis 4 ans et je contribue aux principales plates-formes d'outils d'IA depuis un certain temps maintenant.

Au cours de cette période, j'ai utilisé de nombreux outils et frameworks pour construire ;

• Des agents IA qui fonctionnent réellement dans le monde réel.
• Outils pour les agents IA.
• Applications RAG de bout en bout.

J'ai organisé une liste convoitée d'outils et de frameworks open source qui vous aideront à créer des applications d'IA robustes et fiables. 🔥

N'hésitez pas à explorer leurs référentiels GitHub, à contribuer à vos favoris et à les soutenir en mettant en vedette les référentiels.

1. Composio 👑 - Créez des agents fiables 10 fois plus rapidement

J'ai essayé de créer de nombreux agents et, honnêtement, même s'il est facile de les créer, c'est un jeu de balle totalement différent de les réussir.

Construire des agents d’IA efficaces qui fonctionnent réellement nécessite des ensembles d’outils efficaces. C’est là que Composio entre en scène.

Composio vous permet d'augmenter vos agents d'IA avec des outils et des intégrations robustes pour réaliser les flux de travail d'IA.

Ils fournissent un support natif pour Python et Javascript.

Python

Commencez avec la commande pip suivante.

 pip install composio-core

Ajoutez une intégration GitHub.

 composio add github

Composio gère l'authentification et l'autorisation des utilisateurs en votre nom. Voici comment utiliser l'intégration GitHub pour démarrer un référentiel.

 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} ] )

Exécutez ce script Python pour exécuter l'instruction donnée à l'aide de l'agent.

Javascript

Vous pouvez l'installer en utilisant npm , yarn ou pnpm .

 npm install composio-core

Définissez une méthode pour permettre à l'utilisateur de connecter son compte 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; }

Ajoutez les outils requis au SDK OpenAI et transmettez le nom de l'entité à la 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")

Exécutez le code et laissez l'agent faire le travail à votre place.

Composio fonctionne avec des frameworks célèbres comme LangChain, LlamaIndex, CrewAi, etc.

Pour plus d'informations, visitez la documentation officielle et, pour des exemples même complexes, visitez les sections d'exemples du référentiel.

Star le dépôt Composio.dev ⭐

2. Julep - Framework pour la création d'agents avec état

Le développement d’applications d’IA, en particulier celles nécessitant une mémoire à long terme, présente des défis importants.

Julep résout ce problème. Il s'agit d'un framework open source permettant de créer des agents d'IA avec état prêts pour la production.

Ils fournissent un système de gestion d’état intégré qui facilite le stockage et la récupération efficaces du contexte.

Le stockage contextuel permet de maintenir la continuité des conversations, garantissant que les interactions avec l'IA restent cohérentes et contextuellement pertinentes au fil du temps.

Commencez avec la commande pip suivante.

 pip install julep

Voici comment cela fonctionne.

 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)))

Ils prennent également en charge Javascript. Consultez leur documentation pour en savoir plus.

Star le dépôt Julep ⭐

3. E2B - Interprétation de code pour les applications d'IA

Si je crée une application d'IA avec des capacités d'exécution de code, comme un tuteur d'IA ou un analyste de données d'IA, l'interprète de code d'E2B sera mon outil de prédilection.

E2B Sandbox est un environnement cloud sécurisé pour les agents et applications IA.

Il permet à l’IA de fonctionner en toute sécurité pendant de longues périodes, en utilisant les mêmes outils que les humains, tels que les référentiels GitHub et les navigateurs cloud.

Ils proposent des SDK natifs d’interprète de code pour Python et Javascript/Typescript.

Le SDK Code Interpreter vous permet d'exécuter du code généré par l'IA dans une petite VM sécurisée - sandbox E2B - pour l'exécution du code IA. À l'intérieur du bac à sable se trouve un serveur Jupyter que vous pouvez contrôler à partir de leur SDK.

Démarrez avec E2B avec la commande suivante.

 npm i @e2b/code-interpreter

Exécuter un programme.

 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()

Pour en savoir plus sur la façon de travailler avec E2B, visitez leur documentation officielle .

Star le dépôt E2B ⭐

4. Camel-ai - Créer des systèmes d'IA communicatifs

La recherche de systèmes collaboratifs multi-agents évolutifs peut libérer de nombreux potentiels dans la création d’applications d’IA.

Camel est bien placé pour cela. Il s'agit d'un framework open source offrant une approche évolutive pour étudier les comportements et les capacités coopératives des systèmes multi-agents.

Si vous avez l'intention de créer un système multi-agents, Camel peut être l'un des meilleurs choix disponibles sur la scène open source.

Commencez par l'installer avec pip .

 pip install camel-ai

Voici comment utiliser 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)

Voilà, vous avez votre premier agent IA.

Pour plus d'informations, reportez-vous à leur documentation officielle .

Star le référentiel camel-ai ⭐

5. CopilotKit - Créez des copilotes IA pour les applications React

Ne cherchez pas plus loin si vous souhaitez inclure des fonctionnalités d'IA dans votre application React existante. Le CopilotKit vous permet d'utiliser des modèles GPT pour automatiser l'interaction avec le front et le back-end de votre application.

Il s'agit d'un Copilot prêt à l'emploi que vous pouvez intégrer à votre application ou à n'importe quel code auquel vous pouvez accéder (OSS).

Il propose des composants React tels que des zones de texte, des fenêtres contextuelles, des barres latérales et des chatbots pour compléter n'importe quelle application avec des capacités d'IA.

Démarrez avec CopilotKit à l’aide de la commande suivante.

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

Un CopilotKit doit envelopper tous les composants interagissant avec CopilotKit. Vous devez également commencer par CopilotSidebar (passer à un autre fournisseur d'interface utilisateur plus tard).

 "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> ); }

Vous pouvez consulter leur documentation pour plus d'informations.

Star le dépôt CopilotKit ⭐

6. Aider - Le programmeur AI Pair

Imaginez avoir un programmeur en binôme qui est toujours utile et jamais ennuyeux. Eh bien, maintenant c'est fait !

Aider est un programmeur en binôme alimenté par l'IA qui peut démarrer un projet, modifier des fichiers ou travailler avec un référentiel Git existant et bien plus encore à partir du terminal.

Il fonctionne avec les principaux LLM comme GPT4o, Sonnet 3.5, DeepSeek Coder, Llama 70b, etc.

Vous pouvez commencer rapidement comme ceci :

 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

Pour plus de détails, consultez les instructions d'installation et autres documentations .

Star le référentiel Aider ⭐

7. Haystack - Construire des pipelines RAG composables

Il existe de nombreux frameworks pour créer des pipelines d'IA, mais si je souhaite intégrer des pipelines de recherche de bout en bout prêts pour la production dans mon application, Haystack est mon choix.

Qu'il s'agisse de recherches RAG, questions-réponses ou sémantiques, les pipelines hautement composables de Haystack facilitent le développement, la maintenance et le déploiement.

Leur approche épurée et modulaire est ce qui les distingue. Haystack vous permet d'intégrer sans effort des classements, des magasins de vecteurs et des analyseurs dans des pipelines nouveaux ou existants, facilitant ainsi la transformation de vos prototypes en solutions prêtes pour la production.

Haystack est un framework uniquement Python ; vous pouvez l'installer en utilisant. pip .

 pip install haystack-ai

Maintenant, construisez votre premier pipeline RAG avec des composants 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])

Pour plus de didacticiels et de concepts, consultez leur documentation .

Star le référentiel Haystack ⭐

8. Pgvectorscale - Base de données vectorielles la plus rapide

Les applications RAG modernes sont incomplètes sans bases de données vectorielles. Ceux-ci stockent des documents (textes, images) sous forme d'intégrations, permettant aux utilisateurs de rechercher des documents sémantiquement similaires.

Pgvectorscale est une extension de PgVector, une base de données vectorielles de PostgreSQL. Il peut s'intégrer de manière transparente aux bases de données Postgres existantes.

Si vous créez une application avec des magasins de vecteurs, c'est une évidence. Pgvectorscale a surpassé l'indice d'optimisation du stockage de Pinecone (s1). Et cela coûte 75 % de moins.

Vous pouvez l'installer à partir de la source, utiliser un gestionnaire de packages comme Yum, Homebrew, apt, etc., ou utiliser un conteneur Docker.

Pour commencer, compilez et installez.

 # 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

Connectez-vous à votre base de données :

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

Créez l'extension pgvectorscale :

 CREATE EXTENSION IF NOT EXISTS vectorscale CASCADE;

Le CASCADE installe automatiquement pgvector .

Créez un tableau avec une colonne d'intégration. Par exemple:

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

Pour plus d'informations sur la façon de l'utiliser, consultez le référentiel .

Star le dépôt Pgvectorscale ⭐

9. GPTCache - Mise en cache sémantique pour les applications d'IA

Les LLM coûtent cher.

Si vous créez une application qui nécessite des conversations plus étendues avec des modèles de chat et que vous ne souhaitez pas maximiser les cartes de crédit, vous avez besoin d'une mise en cache.

Cependant, la mise en cache traditionnelle n’est d’aucune utilité ici. C’est là que GPTCache entre en scène.

Il s'agit d'un outil de mise en cache sémantique de Zilliz, l'organisation mère du magasin de vecteurs Milvus.

Il vous permet de stocker des conversations dans vos magasins vectoriels préférés. Avant d'envoyer une requête au LLM, il effectue une recherche dans le magasin de vecteurs ; s'il y a un résultat, il le récupère. Sinon, il achemine la demande vers le modèle.

Pour plus d’informations, visitez la page de documentation officielle.

Star le dépôt GPTCache ⭐

10. Mem0 (EmbedChain) - Créez des applications LLM personnalisées

Mem0 fournit une couche de mémoire intelligente et auto-améliorée pour les grands modèles de langage.

Il vous permet d'ajouter de la mémoire persistante pour les utilisateurs, les agents et les sessions. Considérez Mem0 si vous créez un chatbot ou un système de questions-réponses sur des données personnalisées.

Commencez avec Mem0 en utilisant. pip .

 pip install mem0ai

Voici comment utiliser Mem0 pour ajouter une couche mémoire aux grands modèles linguistiques.

 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)

Reportez-vous à la documentation officielle pour en savoir plus.

Star le référentiel Mem0 (Embedchain) ⭐

11. FastEmbed - Intégrez des documents plus rapidement

La vitesse d’exécution est primordiale dans le développement de logiciels, et elle l’est encore plus lors de la création d’une application d’IA.

Habituellement, la génération intégrée peut prendre beaucoup de temps, ralentissant l’ensemble du pipeline. Toutefois, cela ne devrait pas être le cas.

FastEmbed de Qdrant est une bibliothèque Python rapide et légère conçue pour la génération d'intégration.

Il utilise le runtime ONNX au lieu de Pytorch, ce qui le rend plus rapide. Il prend également en charge la plupart des modèles d'intégration open source de pointe.

Pour démarrer avec FastEmbed, installez-le en utilisant pip .

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

Voici comment créer les intégrations des documents.

 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

Consultez leur référentiel pour plus d'informations.

Star le référentiel FastEmbed ⭐

12. Instructeur - Extraction de données structurées à partir de LLM

Si vous avez joué avec les résultats du LLM, vous savez qu'il peut être difficile de valider des réponses structurées.

Instructor est un outil open source qui rationalise la validation, les nouvelles tentatives et la diffusion en continu des résultats LLM.

Il utilise Pydantic pour Python et Zod pour JS/TS pour la validation des données et prend en charge divers fournisseurs de modèles au-delà d'openAI.

Démarrez avec l'instructeur à l'aide de la commande suivante.

 npm i @instructor-ai/instructor zod openai

Voici maintenant comment extraire des données structurées à partir des réponses 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" }

Pour plus d’informations, visitez la page de documentation officielle.

Star l'instructeur ⭐

13. LiteLLM - Remplacement instantané des LLM au format OpenAI

Soyons honnêtes; nous avons tous crié à un moment donné parce qu'un nouveau fournisseur de modèles ne suit pas le format OpenAI SDK pour la génération de texte, d'image ou d'intégration.

Cependant, avec LiteLLM, en utilisant le même format d'implémentation, vous pouvez utiliser n'importe quel fournisseur de modèles (Claude, Gemini, Groq, Mistral, Azure AI, Bedrock, etc.) en remplacement immédiat des modèles OpenAI.

Ils prennent également en charge l'équilibrage de charge, les solutions de repli et le suivi des dépenses sur plus de 100 LLM.

Installez LiteLLM en utilisant pip .

 pip install litellm

Voici comment utiliser le modèle Claude-2 en remplacement des modèles 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"}] )

Pour en savoir plus, reportez-vous à leur documentation officielle .

Star le LiteLLM ⭐

Utilisez-vous ou avez-vous construit un autre outil ou framework sympa ?

Faites-le moi savoir dans les commentaires :)