Diese 13 versteckten Open-Source-Bibliotheken helfen Ihnen, ein KI-Zauberer zu werden 🧙‍♂️🪄

Ich habe in den letzten vier Jahren KI-Anwendungen entwickelt und trage seit einiger Zeit zu wichtigen KI-Tooling-Plattformen bei.

In dieser Zeit habe ich viele Werkzeuge und Frameworks zum Erstellen verwendet;

• KI-Agenten, die tatsächlich in der realen Welt funktionieren.
• Tools für KI-Agenten.
• End-to-End-RAG-Anwendungen.

Ich habe eine begehrte Liste mit Open-Source-Tools und Frameworks zusammengestellt, die Ihnen bei der Entwicklung robuster und zuverlässiger KI-Anwendungen helfen. 🔥

Erkunden Sie ihre GitHub-Repositories, tragen Sie zu Ihren Favoriten bei und unterstützen Sie sie, indem Sie die Repositories mit einem Stern markieren.

1. Composio 👑 - Erstellen Sie zuverlässige Agenten 10x schneller

Ich habe versucht, viele Agenten zu erstellen. Ehrlich gesagt ist es zwar einfach, sie zu erstellen, aber sie richtig hinzubekommen, ist eine ganz andere Sache.

Für den Aufbau effizienter KI-Agenten, die tatsächlich funktionieren, sind effiziente Toolsets erforderlich. Hier kommt Composio ins Spiel.

Mit Composio können Sie Ihre KI-Agenten mit robusten Tools und Integrationen erweitern, um KI-Workflows durchzuführen.

Sie bieten native Unterstützung für Python und Javascript.

Python

Beginnen Sie mit dem folgenden pip Befehl.

 pip install composio-core

Fügen Sie eine GitHub-Integration hinzu.

 composio add github

Composio übernimmt die Benutzerauthentifizierung und -autorisierung in Ihrem Namen. So können Sie die GitHub-Integration verwenden, um ein Repository zu starten.

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

Führen Sie dieses Python-Skript aus, um die angegebene Anweisung mithilfe des Agenten auszuführen.

Javascript

Sie können es mit npm , yarn oder pnpm installieren.

 npm install composio-core

Definieren Sie eine Methode, mit der der Benutzer sein GitHub-Konto verbinden kann.

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

Fügen Sie dem OpenAI SDK die erforderlichen Tools hinzu und übergeben Sie den Entitätsnamen an die Funktion 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")

Führen Sie den Code aus und überlassen Sie die Arbeit dem Agenten.

Composio funktioniert mit bekannten Frameworks wie LangChain, LlamaIndex, CrewAi usw.

Weitere Informationen finden Sie in der offiziellen Dokumentation . Noch komplexere Beispiele finden Sie in den Beispielabschnitten des Repository.

Markieren Sie das Composio.dev-Repository mit einem Stern ⭐

2. Julep - Framework zum Erstellen von Stateful Agents

Die Entwicklung von KI-Anwendungen, insbesondere solcher, die ein Langzeitgedächtnis erfordern, stellt erhebliche Herausforderungen dar.

Julep löst dieses Problem. Es handelt sich um ein Open-Source-Framework zum Erstellen produktionsreifer Stateful-AI-Agenten.

Sie verfügen über ein integriertes Statusverwaltungssystem, das die effiziente Speicherung und Abfrage von Kontexten unterstützt.

Durch die Kontextspeicherung wird die Kontinuität der Konversation aufrechterhalten und sichergestellt, dass die Interaktionen mit der KI im Laufe der Zeit kohärent und kontextbezogen relevant bleiben.

Beginnen Sie mit dem folgenden pip Befehl.

 pip install julep

So funktioniert es.

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

Sie unterstützen auch Javascript. Weitere Informationen finden Sie in der Dokumentation .

Markieren Sie das Julep-Repository mit einem Stern ⭐

3. E2B – Code-Interpretation für KI-Apps

Wenn ich eine KI-App mit Codeausführungsfunktionen erstelle, etwa einen KI-Tutor oder einen KI-Datenanalysten, ist der Code Interpreter von E2B mein bevorzugtes Tool.

E2B Sandbox ist eine sichere Cloud-Umgebung für KI-Agenten und Apps.

Dadurch kann KI über lange Zeiträume sicher ausgeführt werden und dabei dieselben Tools wie Menschen verwenden, etwa GitHub-Repositories und Cloud-Browser.

Sie bieten native Code Interpreter SDKs für Python und Javascript/Typescript.

Mit dem Code Interpreter SDK können Sie KI-generierten Code in einer sicheren kleinen VM – E2B-Sandbox – zur KI-Codeausführung ausführen. In der Sandbox befindet sich ein Jupyter-Server, den Sie über das SDK steuern können.

Beginnen Sie mit E2B mit dem folgenden Befehl.

 npm i @e2b/code-interpreter

Führen Sie ein Programm aus.

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

Weitere Informationen zur Arbeit mit E2B finden Sie in der offiziellen Dokumentation .

Markieren Sie das E2B-Repository mit einem Stern ⭐

4. Camel-ai – Bauen Sie kommunikative KI-Systeme

Durch die Lösung skalierbarer Multi-Agenten-Kollaborationssysteme können beim Erstellen von KI-Anwendungen viele Potenziale freigesetzt werden.

Camel ist hierfür bestens geeignet. Es handelt sich um ein Open-Source-Framework, das einen skalierbaren Ansatz für die Untersuchung des kooperativen Verhaltens und der kooperativen Fähigkeiten von Multi-Agenten-Systemen bietet.

Wenn Sie ein Multiagentensystem erstellen möchten, kann Camel eine der besten verfügbaren Optionen in der Open-Source-Szene sein.

Beginnen Sie mit der Installation mit pip .

 pip install camel-ai

So verwenden Sie 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)

Voila, Sie haben Ihren ersten KI-Agenten.

Weitere Informationen finden Sie in der offiziellen Dokumentation .

Markieren Sie das Camel-AI-Repository mit einem Stern ⭐

5. CopilotKit – Erstellen Sie KI-Copiloten für React-Apps

Wenn Sie KI-Funktionen in Ihre vorhandene React-Anwendung integrieren möchten, sind Sie hier richtig. Mit dem CopilotKit können Sie GPT-Modelle verwenden, um die Interaktion mit dem Front- und Backend Ihrer Anwendung zu automatisieren.

Es handelt sich um einen vorgefertigten Copiloten, den Sie in Ihre Anwendung oder in jeden Code, auf den Sie zugreifen können (OSS), integrieren können.

Es bietet React-Komponenten wie Textbereiche, Popups, Seitenleisten und Chatbots, um jede Anwendung mit KI-Funktionen zu erweitern.

Beginnen Sie mit CopilotKit mit dem folgenden Befehl.

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

Ein CopilotKit muss alle Komponenten umschließen, die mit CopilotKit interagieren. Sie sollten auch mit CopilotSidebar beginnen (später zu einem anderen UI-Anbieter wechseln).

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

Weitere Informationen finden Sie in der Dokumentation .

Markieren Sie das CopilotKit-Repository mit einem Stern ⭐

6. Aider – Der KI-Paarprogrammierer

Stellen Sie sich vor, Sie hätten einen Paarprogrammierer, der immer hilfsbereit und nie nervig ist. Nun, jetzt haben Sie ihn!

Aider ist ein KI-gestützter Paarprogrammierer, der vom Terminal aus ein Projekt starten, Dateien bearbeiten oder mit einem vorhandenen Git-Repository arbeiten und mehr kann.

Es funktioniert mit führenden LLMs wie GPT4o, Sonnet 3.5, DeepSeek Coder, Llama 70b usw.

So können Sie schnell loslegen:

 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

Weitere Einzelheiten finden Sie in den Installationsanweisungen und anderer Dokumentation .

Markieren Sie das Aider-Repository mit einem Stern ⭐

7. Haystack – Erstellen Sie zusammensetzbare RAG-Pipelines

Es gibt viele Frameworks zum Erstellen von KI-Pipelines, aber wenn ich produktionsreife End-to-End-Suchpipelines in meine Anwendung integrieren möchte, ist Haystack meine erste Wahl.

Ob RAG, Q&A oder semantische Suchen – die hochgradig zusammensetzbaren Pipelines von Haystack machen Entwicklung, Wartung und Bereitstellung zum Kinderspiel.

Ihr klarer und modularer Ansatz ist das, was sie auszeichnet. Mit Haystack können Sie Ranker, Vektorspeicher und Parser mühelos in neue oder bestehende Pipelines integrieren, sodass Sie Ihre Prototypen ganz einfach in produktionsreife Lösungen verwandeln können.

Haystack ist ein reines Python-Framework; Sie können es mit pip installieren.

 pip install haystack-ai

Bauen Sie jetzt Ihre erste RAG-Pipeline mit Haystack-Komponenten.

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

Weitere Tutorials und Konzepte finden Sie in der Dokumentation .

Markieren Sie das Haystack-Repository mit einem Stern ⭐

8. Pgvectorscale - Schnellste Vektordatenbank

Moderne RAG-Anwendungen sind ohne Vektordatenbanken unvollständig. Diese speichern Dokumente (Texte, Bilder) als Einbettungen und ermöglichen so die Suche nach semantisch ähnlichen Dokumenten.

Pgvectorscale ist eine Erweiterung von PgVector, einer Vektordatenbank von PostgreSQL. Es lässt sich nahtlos in vorhandene Postgres-Datenbanken integrieren.

Wenn Sie eine Anwendung mit Vektorspeichern erstellen, ist dies ein Kinderspiel. Pgvectorscale hat den speicheroptimierten Index (s1) von Pinecone übertroffen. Und es kostet 75 % weniger.

Sie können es von der Quelle installieren, einen Paketmanager wie Yum, Homebrew, apt usw. verwenden oder einen Docker-Container verwenden.

Um damit zu beginnen, kompilieren und installieren Sie es.

 # 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

Stellen Sie eine Verbindung zu Ihrer Datenbank her:

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

Erstellen Sie die pgvectorscale-Erweiterung:

 CREATE EXTENSION IF NOT EXISTS vectorscale CASCADE;

CASCADE installiert pgvector automatisch.

Erstellen Sie eine Tabelle mit einer eingebetteten Spalte. Beispiel:

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

Weitere Informationen zur Verwendung finden Sie im Repository .

Markieren Sie das Pgvectorscale-Repository mit einem Stern ⭐

9. GPTCache – Semantisches Caching für KI-Apps

LLMs sind teuer.

Wenn Sie eine App erstellen, die längere Gespräche mit Chat-Modellen erfordert, und Sie Ihre Kreditkarte nicht bis zum Limit ausreizen möchten, benötigen Sie Caching.

Allerdings nützt herkömmliches Caching hier nichts. Hier kommt GPTCache ins Spiel.

Es handelt sich um ein semantisches Caching-Tool von Zilliz, der Dachorganisation des Milvus-Vektor-Stores.

Damit können Sie Konversationen in Ihren bevorzugten Vektorspeichern speichern. Bevor eine Abfrage an das LLM gesendet wird, durchsucht es den Vektorspeicher. Wenn ein Treffer gefunden wird, wird dieser abgerufen. Andernfalls wird die Abfrage an das Modell weitergeleitet.

Weitere Informationen finden Sie auf der offiziellen Dokumentationsseite .

Markieren Sie das GPTCache-Repository mit einem Stern ⭐

10. Mem0 (EmbedChain) - Erstellen Sie personalisierte LLM-Apps

Mem0 bietet eine intelligente, sich selbst verbessernde Speicherschicht für große Sprachmodelle.

Damit können Sie persistenten Speicher für Benutzer, Agenten und Sitzungen hinzufügen. Erwägen Sie Mem0, wenn Sie einen Chatbot oder ein Q&A-System auf der Grundlage benutzerdefinierter Daten erstellen.

Beginnen Sie mit Mem0 mithilfe von pip .

 pip install mem0ai

So verwenden Sie Mem0, um großen Sprachmodellen eine Speicherebene hinzuzufügen.

 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)

Weitere Informationen finden Sie in der offiziellen Dokumentation .

Markieren Sie das Mem0-Repository (Embedchain) mit einem Stern ⭐

11. FastEmbed - Dokumente schneller einbetten

Bei der Softwareentwicklung ist die Ausführungsgeschwindigkeit von größter Bedeutung und beim Erstellen einer KI-Anwendung ist sie noch wichtiger.

Normalerweise kann die Einbettungsgenerierung lange dauern und die gesamte Pipeline verlangsamen. Dies sollte jedoch nicht der Fall sein.

FastEmbed von Qdrant ist eine schnelle, leichte Python-Bibliothek zur Einbettungsgenerierung.

Es verwendet die ONNX-Laufzeit anstelle von Pytorch und ist dadurch schneller. Außerdem unterstützt es die meisten modernen Open-Source-Einbettungsmodelle.

Um mit FastEmbed zu beginnen, installieren Sie es mit pip .

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

So können Sie die Einbettungen der Dokumente erstellen.

 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

Weitere Informationen finden Sie in ihrem Repository .

Markieren Sie das FastEmbed-Repository mit einem Stern ⭐

12. Dozent - Strukturierte Datenextraktion aus LLMs

Wenn Sie schon einmal mit LLM-Ausgaben experimentiert haben, wissen Sie, dass die Validierung strukturierter Antworten eine Herausforderung sein kann.

Instructor ist ein Open-Source-Tool, das die Validierung, Wiederholung und das Streaming von LLM-Ausgaben optimiert.

Es verwendet Pydantic für Python und Zod für JS/TS zur Datenvalidierung und unterstützt verschiedene Modellanbieter über openAI hinaus.

Beginnen Sie mit dem Instructor, indem Sie den folgenden Befehl verwenden.

 npm i @instructor-ai/instructor zod openai

So können Sie strukturierte Daten aus LLM-Antworten extrahieren.

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

Weitere Informationen finden Sie auf der offiziellen Dokumentationsseite .

Markieren Sie den Kursleiter mit einem Stern ⭐

13. LiteLLM – Drop-in-Ersatz für LLMs im OpenAI-Format

Seien wir ehrlich: Wir alle haben schon einmal aufgeschrien, weil ein neuer Modellanbieter nicht dem OpenAI SDK-Format für die Generierung von Text, Bildern oder Einbettungen folgt.

Mit LiteLLM können Sie jedoch unter Verwendung desselben Implementierungsformats jeden beliebigen Modellanbieter (Claude, Gemini, Groq, Mistral, Azure AI, Bedrock usw.) als Drop-In-Ersatz für OpenAI-Modelle verwenden.

Sie unterstützen außerdem Lastausgleich, Fallbacks und Ausgabenverfolgung für mehr als 100 LLMs.

Installieren Sie LiteLLM mit pip .

 pip install litellm

So können Sie das Claude-2-Modell als Drop-In-Ersatz für GPT-Modelle verwenden.

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

Weitere Informationen finden Sie in der offiziellen Dokumentation .

Markieren Sie das LiteLLM ⭐

Verwenden Sie ein anderes cooles Tool oder Framework oder haben Sie ein anderes erstellt?

Lass es mich in den Kommentaren wissen :)