This will be an exciting year for tech, and we may see some breakthrough achievements across multiple domains, AI tools, frameworks, databases, and more,
So, I have curated some open-source tools you must use to build your next big project.
1. Composio: Integrate AI with external SaaS for automation
2025 is going to be the year of AI agents. However, AI agents are as useful as the tools they have, and Composio is the leading platform offering tools and integrations for your AI agents to communicate with external apps like GitHub, Gmail, etc.
Think of Composio as the bridging layer between the agents and your apps. For example, with Composio, you can add Gmail, Calendar, Meet, Notion, etc, to build an agent that can summarise your meetings, create action points, update your calendar (if needed), and send emails to appropriate attendees.
Getting started with it is very easy.
npm install composio-core openai
Connect your GitHub Account
import { Composio } from "composio-core";
const client = new Composio({ apiKey: "<your-api-key>" });
const entity = await client.getEntity("Jessica");
const connection = await entity.initiateConnection({appName: 'github'});
console.log(`Open this URL to authenticate: ${connection.redirectUrl}`);
Initialize Composio and OpenAI
import { OpenAI } from "openai";
import { OpenAIToolSet } from "composio-core";
const openai_client = new OpenAI();
const composio_toolset = new OpenAIToolSet();
Fetch GitHub actions and pass them to the LLM
const tools = await composio_toolset.getTools({
actions: ["github_star_a_repository_for_the_authenticated_user"]
});
const instruction = "Star the repo composiohq/composio on GitHub";
const response = await openai_client.chat.completions.create({
model: "gpt-4o",
messages: [{ role: "user", content: instruction }],
tools: tools,
tool_choice: "auto",
});
Execute the tool calls.
const result = await composio_toolset.handleToolCall(response);
console.log(result);
The documentation provides more on Composio, its work, and important concepts for making capable production-ready agents.
Star the Composio repository ⭐
2. Encore: Developer-First Backend Framework with Automated Infrastructure
Encore is a backend framework you should consider building with. It eliminates all the hassle of cloud development and cloud infrastructure setup and management, from API documentation to database provisioning, service discovery to deployment pipelines, and monitoring to tracing, letting you focus purely on writing your application code.
Encore is like having a DevOps expert built into your workflow - you focus on writing TypeScript or Go code. At the same time, it handles all the complex infrastructure behind the scenes, from database management to microservices deployment. It transforms complex cloud development into simple, maintainable code.
Get started with Encore by installing the CLI.
curl -L https://encore.dev/install.sh | bash
Create an app.
encore app create
This will configure your free account, allow you to choose your app's name, and select the Hello World template.
This will create a new folder with an example application and a simple REST API using your chosen app name.
Open the file in your editor.
// Service hello implements a simple hello world REST API.
package hello
import (
"context"
)
// This simple REST API responds with a personalized greeting.
//
//encore:api public path=/hello/:name
func World(ctx context.Context, name string) (*Response, error) {
msg := "Hello, " + name + "!"
return &Response{Message: msg}, nil
}
type Response struct {
Message string
}
For more information, refer to their documentation.
3. Val Town: Social Computing Platform for Running Serverless JavaScript
Think of it as your personal JavaScript playground in the cloud. Val Town lets you write and deploy code snippets that run as APIs or automation without dealing with servers or infrastructure. It's perfect for quick prototypes or automating repetitive tasks.
Create a new Val:
// @username/greet
export function greet(name) {
return `Hello, ${name}!`
}
Import and use other people's Vals:
import { greet } from "@friend/greet"
export function welcome() {
return greet("Val Town")
}
Every Val is an API endpoint and can be scheduled like a cron job. It's perfect for automation, bots, and quick experiments!
4. Neon: Serverless Postgress
You've probably heard of Neon if you've ever struggled with managing PostgreSQL databases in a serverless environment. What makes it special is that it brings Git-like branching to databases, letting you create instant copies of your database for testing or development.
It's perfect for modern development workflows where you want to test changes without messing with your production data.
5. Rustify: A Rust library for interacting with HTTP API endpoints
Rustify is a small library written in Rust that eases the burden of scaffolding HTTP APIs. It provides an endpoint trait and a macro helper that allows the templating of various remote endpoints. Both asynchronous and synchronous clients are offered to execute requests against endpoints, with the option of implementing custom clients using the Client trait.
Basic example
use rustify::{Client, Endpoint};
use rustify_derive::Endpoint;
// Defines an API endpoint at /test/path that takes no inputs and returns an
// empty response.
#[derive(Endpoint)]
#[endpoint(path = "test/path")]
struct Test {}
let endpoint = Test {};
let client = Client::default("http://api.com"); // Configures base address of http://api.com
let result = endpoint.exec(&client).await; // Sends GET request to http://api.com/test/path
assert!(result.is_ok());
6. Trigger Dev: Open source background jobs platform
A developer-first background jobs framework that makes handling scheduled tasks and webhooks feel natural. Unlike traditional job queues, Trigger.dev has built-in versioning, retries, and a beautiful dashboard to monitor your jobs.
The real magic happens with its integrations – you can connect with GitHub, Stripe, or any API without writing boilerplate code. It's especially powerful for handling webhook-driven workflows or running resource-intensive background tasks without affecting your main application.
# Install
npm install @trigger.dev/sdk
typescript
Copy
import { TriggerClient } from "@trigger.dev/sdk";
const client = new TriggerClient({
id: "my-app",
apiKey: process.env.TRIGGER_API_KEY,
});
// Create a scheduled job
client.defineJob({
id: "daily-cleanup",
name: "Daily Cleanup",
version: "1.0.0",
trigger: "schedule",
schedule: "0 0 * * *",
run: async (payload, io) => {
// Built-in integrations
await io.github.createIssue("org/repo", {
title: "Daily Cleanup Report",
body: "Cleanup completed successfully"
});
},
});
7. Tolgee: Open-source localization tool
Tolgee is an innovative open-source localization platform that is transforming how developers handle application translations. It enables in-context translation directly within your application through a simple ALT+click interface, eliminating the need to edit traditional localization files.
8. OpenTelemetry: Effective observability made easy
Gone are the days of piecing together different monitoring tools. OpenTelemetry is the Swiss Army knife of observability, giving you everything you need to monitor your systems.
It's a comprehensive framework that collects traces, metrics, and logs across your entire infrastructure, making it easier to understand what's happening in complex, distributed applications. Whether running microservices in Kubernetes or traditional applications, OpenTelemetry provides a unified way to gather and analyze performance data without vendor lock-in.
# Install for Node.js
npm install @opentelemetry/api @opentelemetry/sdk-node
import { NodeSDK } from '@opentelemetry/sdk-node'
import { trace } from '@opentelemetry/api'
const sdk = new NodeSDK()
sdk.start()
// Create a span
const tracer = trace.getTracer('my-app')
const span = tracer.startSpan('my-operation')
span.end()
9. ChromaDB: Performant vector database
Building AI applications that need to understand and search through content? ChromaDB has got your back. It's an open-source embedding database that makes vector search feel like a breeze.
Getting started with it is easy.
pip install chromadb
import chromadb
client = chromadb.Client()
collection = client.create_collection("docs")
# Add documents
collection.add(
documents=["ChromaDB is awesome", "Vector databases are the future"],
ids=["1", "2"]
)
# Search
results = collection.query(
query_texts=["What's awesome?"],
n_results=1
)
10. Hono: An ultralight web framework for edge devices
An ultralight web framework built for the edge. While other frameworks started with servers in mind, Hono was explicitly designed for edge computing platforms like Cloudflare Workers and Deno Deploy. It's swift, has a tiny footprint, and provides a familiar Express-like API.
Getting started with it is very easy.
npm create hono@latest
A simple example
import { Hono } from 'hono'
const app = new Hono()
app.get('/', (c) => c.text('Hono!'))
export default app
11. Astro: The web framework for content driven websites
A web framework that's changing how we think about shipping JavaScript: Astro delivers lightning-fast websites by default, sending zero JavaScript to the client unless you explicitly need it. What sets it apart is its "Islands Architecture" – you can mix and match React, Vue, or Svelte components in the same project, and Astro will only hydrate what's necessary.
This means you get the best of both worlds: dynamic components where you need them and static, blazing-fast HTML everywhere else. Perfect for content-heavy sites that need selective interactivity.
#create new project
npm create astro@latest
---
// pages/index.astro
const data = await fetch('api/posts').then(r => r.json())
---
<html>
<body>
{data.map(post => (
<article>
<h2>{post.title}</h2>
<p>{post.excerpt}</p>
</article>
))}
</body>
</html>
12. Grafbase: GraphQL federation platform
Grafbase lets you define your API schema with TypeScript and handles all the backend complexities. What's cool is how it connects with your existing tools—from Auth0 for authentication to S3 for file storage.
Plus, it automatically deploys your API to the edge, making it blazing fast no matter where your users are. It's perfect for teams that want a modern GraphQL backend without the operational headaches.
# Install Grafbase CLI
npm install -g grafbase
# Initialize a new project
grafbase init my-api
// schema.ts
type Post @model {
id: ID!
title: String!
content: String
author: User!
}
type User @model {
id: ID!
name: String!
posts: [Post]
}
13. Letta: Build LLMs with memory
Letta is an innovative AI platform that brings advanced memory capabilities to LLM-based agents. Founded in UC Berkeley's Sky Computing Lab, it enables AI agents to maintain persistent memory and state across interactions.
Creating an Agent
from letta import EmbeddingConfig, LLMConfig, create_client
client = create_client()
# set automatic defaults for LLM/embedding config
client.set_default_llm_config(LLMConfig.default_config(model_name="gpt-4"))
client.set_default_embedding_config(EmbeddingConfig.default_config(model_name="text-embedding-ada-002"))
# create a new agent
agent_state = client.create_agent()
print(f"Created agent with name {agent_state.name} and unique ID {agent_state.id}")
Once an agent is created, you can message it:
# Message an agent
response = client.send_message(
agent_id=agent_state.id,
role="user",
message="hello"
)
print("Usage", response.usage)
print("Agent messages", response.messages)
For more, check out the documentation.
Thank you for reading, and again, a happy new year.
Top comments (16)
Great roundup of open-source tools! 👏
Not open-source, but definitely worth checking out too: Exocoding. We just launched, and it’s free to use! It’s all about giving devs the freedom to generate code without low-code constraints or vendor lock-in.
Would love to hear your thoughts if you give it a spin!
Oh, that's great. It actually looks promising.
You also need DB2Rest to turn your database into REST API in minutes to quickly build your apps.
DB2Rest.com
Good list, thank you!
I'm glad you liked Maksim.
Thanks for this list. i have been using Hono it's great.
I was thinking something like Encore. Might be a goos fit for our next project.
Great list, I am building an AI code reviewing agent for my local use cases. Composio seems good for this. Thanks.
Thank you, it's great.
Great list! I can't wait to try Val Town & Hono.
I haven't tried Astro yet, but a similar open source alternative that fits the same use case but maybe has more purposes might be Modulo.js. I just used it to soft launch an early version of a "static" PWA Daily Write, and I highly recommend the framework!
You have a certificate warning.
Great share!
Thanks for ai-intergration tool sharing
Great.