9 Must‑Try Open‑Source AI Tools to Supercharge Your Projects

Artificial intelligence is now ubiquitous, and many developers want to embed AI capabilities into their applications. This article compiles a useful list of open‑source repositories and tools that can help you learn and master AI magic.

1. Composio: Build AI automation 10× faster

Composio simplifies integration of popular apps such as GitHub, Slack, Jira, and Airtable with AI agents, handling authentication and authorization for you. It is SOC2‑certified.

Address: https://dub.composio.dev/nv5Oz3n

Installation and usage example:

pip install composio-core

composio add github

from openai import OpenAI
from composio_openai import ComposioToolSet, App
openai_client = OpenAI(api_key="******OPENAIKEY******")
composio_toolset = ComposioToolSet(api_key="**\*\***COMPOSIO_API_KEY**\*\***")
actions = composio_toolset.get_actions(actions=[Action.GITHUB_ACTIVITY_STAR_REPO_FOR_AUTHENTICATED_USER])
my_task = "Star a repo ComposioHQ/composio on GitHub"
response = openai_client.chat.completions.create(
    model="gpt-4-turbo",
    tools=actions,
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": my_task}
    ]
)

Composio works well with LangChain, LlamaIndex, CrewAI and other frameworks.

2. Unsloth: Faster training and fine‑tuning of AI models

Unsloth is a top library for fine‑tuning large language models (LLM) such as Llama‑3, Mistral, Yi, and Open‑hermes. It provides full, LoRA, and QLoRA fine‑tuning with custom Triton kernels for speed.

Address: https://unsloth.ai/

pip install --upgrade pip
pip install "unsloth[cu121-torch240] @ git+https://github.com/unslothai/unsloth.git"

Simple script to fine‑tune a Mistral model:

from unsloth import FastLanguageModel
from unsloth import is_bfloat16_supported
import torch
from trl import SFTTrainer
from transformers import TrainingArguments
from datasets import load_dataset
max_seq_length = 2048
url = "https://huggingface.co/datasets/laion/OIG/resolve/main/unified_chip2.jsonl"
dataset = load_dataset("json", data_files={"train": url}, split="train")
fourbit_models = ["unsloth/mistral-7b-v0.3-bnb-4bit"]
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/llama-3-8b-bnb-4bit",
    max_seq_length=max_seq_length,
    dtype=None,
    load_in_4bit=True,
)
model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    target_modules=["q_proj","k_proj","o_proj","gate_proj","up_proj","down_proj"],
    lora_alpha=16,
    lora_dropout=0,
    bias="none",
    use_gradient_checkpointing="unsloth",
    random_state=3407,
    max_seq_length=max_seq_length,
    use_rslora=False,
    loftq_config=None,
)
trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=max_seq_length,
    tokenizer=tokenizer,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        warmup_steps=10,
        max_steps=60,
        fp16=not is_bfloat16_supported(),
        bf16=is_bfloat16_supported(),
        logging_steps=1,
        output_dir="outputs",
        optim="adamw_8bit",
        seed=3407,
    ),
)
trainer.train()

More details are available in the official documentation.

3. DsPy: LLM programming framework

DsPy tackles LLM randomness by separating program flow from parameters and introducing an optimizer that automatically tunes prompts and weights for accuracy or error reduction.

Address: https://github.com/stanfordnlp/dspy

Key features:

Separate program flow from step parameters for easier management.

Advanced optimizer automatically fine‑tunes prompts and weights.

Quick‑start notebook: https://github.com/stanfordnlp/dspy/blob/main/intro.ipynb

4. TaiPy: Build AI web apps faster with Python

TaiPy is an open‑source Python library that extends Streamlit and Gradio, enabling data scientists to deploy production‑grade AI web applications without learning new languages.

Address: https://taipy.io/

pip install taipy

Example: a simple movie‑recommendation app using TaiPy.

import taipy as tp
import pandas as pd
from taipy import Config, Scope, Gui

def on_genre_selected(state):
    scenario.selected_genre_node.write(state.selected_genre)
    tp.submit(scenario)
    state.df = scenario.filtered_data.read()

def on_init(state):
    on_genre_selected(state)

def filter_genre(initial_dataset: pd.DataFrame, selected_genre):
    filtered_dataset = initial_dataset[initial_dataset["genres"].str.contains(selected_genre)]
    filtered_data = filtered_dataset.nlargest(7, "Popularity %")
    return filtered_data

if __name__ == "__main__":
    Config.load("config.toml")
    scenario_cfg = Config.scenarios["scenario"]
    tp.Core().run()
    scenario = tp.create_scenario(scenario_cfg)
    genres = ["Action","Adventure","Animation","Children","Comedy","Fantasy","IMAX","Romance","Sci-FI","Western","Crime","Mystery","Drama","Horror","Thriller","Film-Noir","War","Musical","Documentary"]
    df = pd.DataFrame(columns=["Title","Popularity %"])
    selected_genre = "Action"
    my_page = """
# Film recommendation
## Choose your favorite genre
<|{selected_genre}|selector|lov={genres}|on_change=on_genre_selected|dropdown|>
## Here are the top seven picks by popularity
<|{df}|chart|x=Title|y=Popularity %|type=bar|title=Film Popularity|>
"""
    Gui(page=my_page).run()

Technical documentation: https://docs.taipy.io/en/latest/getting_started/

5. Phidata: Build LLM agents with memory

Phidata is an open‑source framework that provides reliable ways to create agents with long‑term memory, contextual knowledge, and function‑calling capabilities.

Address: https://www.phidata.com/

pip install -U phidata

Simple financial‑assistant example:

from phi.assistant import Assistant
from phi.llm.openai import OpenAIChat
from phi.tools.yfinance import YFinanceTools
assistant = Assistant(
    llm=OpenAIChat(model="gpt-4o"),
    tools=[YFinanceTools(stock_price=True, analyst_recommendations=True, company_info=True, company_news=True)],
    show_tool_calls=True,
    markdown=True,
)
assistant.print_response("What is the stock price of NVDA")
assistant.print_response("Write a comparison between NVDA and AMD, use all tools available.")

Web‑search assistant example:

from phi.assistant import Assistant
from phi.tools.duckduckgo import DuckDuckGo
assistant = Assistant(tools=[DuckDuckGo()], show_tool_calls=True)
assistant.print_response("Whats happening in France?", markdown=True)

Documentation: https://docs.phidata.com/introduction

6. Phoenix: Efficient LLM observability

Phoenix (by ArizeAI) adds an observability layer to LLM applications, tracking prompts, model parameters, and execution traces to improve reliability.

Address: https://phoenix.arize.com/

pip install arize-phoenix

import phoenix as px
session = px.launch_app()

Integration with LlamaIndex, LangChain, DSPy, and major LLM providers is supported. Example instrumentation with LlamaIndex:

from openinference.instrumentation.llama_index import LlamaIndexInstrumentor
LlamaIndexInstrumentor().instrument()
# Set up LLM and embedding models
Settings.llm = OpenAI(model="gpt-4-turbo-preview")
Settings.embed_model = OpenAIEmbedding(model="text-embedding-ada-002")
# Load index and query
query_engine = index.as_query_engine()
query_engine.query("What is the meaning of life?")
print(px.active_session().url)

7. Airbyte: Reliable, scalable data pipelines

Airbyte provides over 300 connectors for APIs, databases, data warehouses, and lakes, and offers a Python extension (PyAirByte) that integrates with LangChain and LlamaIndex to move data into generative AI apps.

Address: https://airbyte.com/

More technical details are in the official docs.

8. AgentOps: Monitoring and observability for AI agents

AgentOps delivers replay analysis, cost management, benchmarking, compliance, and security tools for AI agents, with native integrations for CrewAI, AutoGen, LangChain, and others.

Address: https://www.agentops.ai/

pip install agentops

import agentops
agentops.init(<INSERT YOUR API KEY HERE>)
# ... your code ...
agentops.end_session('Success')

Documentation provides further examples.

9. RAGAS: Evaluation framework for Retrieval‑Augmented Generation

RAGAS helps evaluate, test, and monitor RAG pipelines by generating synthetic test sets, assessing retrieval quality, and offering production monitoring tools.

Address: https://github.com/stanfordnlp/ragas

Explore the developer docs to improve existing RAG pipelines.