I Built a Searchable GitHub Directory for Hundreds of AI Tools

A while ago, I realized I had a ridiculous system for keeping track of AI tools.

A useful coding assistant? GitHub star.

A research tool? Browser bookmark.

Something interesting I saw online? Leave the tab open and promise myself I would come back to it later.

A tool I really wanted to remember?

Apparently the strategy was to trust my memory.

That worked about as well as you would expect.

So I started organizing everything.

That eventually became Awesome AI Tools: an open, searchable GitHub directory containing hundreds of AI tools across development, agents, research, automation, productivity, image generation, video, audio, LLMs, MLOps, and more.

And the list keeps changing.

New tools can be suggested through issues and pull requests, outdated entries can be fixed, and the catalog can grow with the community.

aliammari1 / awesome-ai-tools

Curated collection of 100+ AI tools designed to enhance productivity and creativity, featuring live demos and APIs for developers

Awesome AI Tools

A curated catalog of 384 AI tools across 19 categories Browse the searchable directory at https://docs.aliammari.dev.

The catalog source of truth is catalog/tools/*.json. This README is generated from that structured catalog; edit catalog records instead of editing tool entries here.

Contents

• AI Agents
• Productivity
• Creativity & Design
• Communication & Writing
• Data Science & Analytics
• Natural Language Processing
• Computer Vision
• Audio & Music
• Video & Media
• Code Generation & Development
• AI Search & Research
• Large Language Models
• Research & Education
• Business & Marketing
• Gaming & Entertainment
• No-Code/Low-Code AI
• AI Safety & Ethics
• Miscellaneous
• Getting Started

AI Agents

Agent SDKs, autonomous systems, orchestration, tool use, memory, and browser automation.

• OpenAI Agents SDK - Lightweight framework for multi-agent workflows with handoffs and guardrails.
• Model Context Protocol - Open standard for connecting AI agents to tools and data sources.
• Claude Agent SDK - Build agents on the same…

View on GitHub

GitHub: Awesome AI Tools

Searchable directory: docs.aliammari.dev

But somewhere along the way, I realized I was no longer solving a bookmarking problem.

I was solving an information architecture problem.

Why I built a curated AI tools directory

Finding AI tools is easy now.

Finding the right one is harder.

Search for "AI coding tool" and you will find dozens.

Search for "AI agent framework" and you will find even more.

The same is true for:

• AI research tools
• AI writing tools
• AI image generators
• AI video generators
• AI automation platforms
• local LLM tools
• AI APIs
• no-code AI tools
• machine learning platforms

More choice should make things easier.

Sometimes it does the opposite.

You end up opening ten tabs, comparing products, forgetting half of them, and eventually using the same tool you already knew.

I wanted something simpler:

Start with the problem you are trying to solve, find the relevant category, and explore useful tools from there.

That became the basic idea behind Awesome AI Tools.

The first version was basically a big README

At first, the project was exactly what you would expect from an "awesome" GitHub repository.

A large Markdown file.

Coding assistants went into one section.

Research tools went into another.

Then came AI agents, LLM frameworks, image generators, automation platforms, productivity tools, MLOps, video, audio, and everything else.

That worked surprisingly well.

Until the list became large enough that the README itself started becoming difficult to maintain.

Then I ran into a funny problem.

I had created a directory to make AI tools easier to find...

...and the directory itself was becoming difficult to navigate.

So I stopped treating it like a list of links

The project now uses a structured catalog as its source of truth.

Instead of manually maintaining hundreds of tool entries inside README.md, tools live as structured records.

Conceptually, an entry looks something like this:

{
  "name": "Example Tool",
  "url": "https://example.com/",
  "description": "One factual sentence describing what the tool does.",
  "category": "code-generation-and-development",
  "openSource": null,
  "pricing": null,
  "status": "listed"
}

That small architectural change made a big difference.

The same catalog can now power:

• the GitHub README
• the searchable website
• validation
• link checking
• future filters
• additional metadata
• automated builds
• community contributions

The README is generated from the catalog rather than acting as the database itself.

That means contributors are not editing a giant Markdown document and hoping everything stays consistent.

Why structured data was worth it

Once a directory contains hundreds of entries, seemingly simple questions become annoying.

Is this tool already listed?

Is the URL still valid?

Which category should it belong to?

Did someone change the README but forget the website?

Is a product discontinued?

Are two entries actually the same product?

Should unknown pricing be marked as free, paid, or simply unknown?

Structured data makes those problems much easier to reason about.

It also lets the project distinguish between:

"We know this value."

and:

"We don't know this value yet."

That is why unknown metadata can remain null instead of being guessed.

For a directory that is supposed to help people make decisions, I would rather have missing data than confidently incorrect data.

What can you find in Awesome AI Tools?

The catalog covers a broad range of AI software.

Here are some of the areas I personally find most useful:

If you're looking for...	Explore tools for...
AI coding tools	code generation, IDE assistants, code review, development
AI agent frameworks	orchestration, browser automation, memory, multi-agent systems
AI research tools	search, academic research, citations, knowledge discovery
LLM tools	models, local inference, APIs, RAG frameworks
AI automation	workflows, agents, no-code and low-code automation
AI productivity tools	scheduling, meetings, email, task management
AI image tools	image generation, editing, design
AI video and audio tools	video generation, transcription, speech, music
MLOps tools	deployment, monitoring, experiment tracking, infrastructure

The exact catalog keeps evolving, so I intentionally do not think of it as a finished list.

That is the point.

AI coding tools have become an ecosystem of their own

One category that changed much faster than I expected is AI-assisted development.

"AI coding tool" used to mostly mean autocomplete.

Now that phrase can describe completely different products.

Some tools autocomplete code.

Some edit multiple files.

Some understand large codebases.

Some live inside your IDE.

Some work from the terminal.

Some review pull requests.

Some generate applications from natural language.

Some behave more like autonomous software-engineering agents.

Putting these tools next to each other makes the evolution of AI development tooling much easier to see.

It also helps answer a more useful question than:

"What is the best AI coding tool?"

The better question is:

"What type of AI coding tool fits the workflow I actually have?"

AI agents have the same problem

"AI agent" is another term that now covers a huge range of software.

The catalog includes tools related to things like:

• agent SDKs
• tool calling
• multi-agent orchestration
• browser automation
• memory
• autonomous workflows
• human-in-the-loop systems
• application frameworks

That variety is exactly why categorization matters.

Without some structure, a list of "AI agent tools" quickly becomes a pile of products that solve very different problems.

AI search and research tools are also more diverse than they look

Another category I keep coming back to is AI search and research.

Research with AI can mean:

• searching the live web
• searching academic papers
• exploring related research
• checking citations
• summarizing sources
• asking questions about documents
• synthesizing evidence
• finding similar content

Those are different workflows.

Treating all of them as "AI search" hides the distinction.

Good categories should make those differences easier to understand.

The hardest part isn't adding tools

Adding another entry takes very little time.

Maintaining a directory is the difficult part.

Products disappear.

Companies pivot.

Domains change.

Projects get archived.

Free plans become paid.

Names change.

Features move.

Entire categories become outdated surprisingly quickly.

That is why I became much more interested in the maintenance side of the project.

A contribution now goes through checks before becoming part of the generated catalog.

The project can validate its structured data, regenerate the README, check links, run linting, and build the searchable site.

That may sound excessive for an AI tools list.

After maintaining hundreds of entries, it does not feel excessive at all.

What does "curated" actually mean?

This was another thing I had to think about.

Anyone can make a giant list.

That does not automatically make it useful.

For Awesome AI Tools, I want entries to meet a basic quality bar.

Real and reachable

The product or repository should actually exist and be accessible.

Actively maintained

Projects that have disappeared or been abandoned should not silently remain forever.

Distinct

Adding several nearly identical wrappers does not necessarily improve the catalog.

Legitimate

The directory should not become a collection of scams, misleading products, or affiliate traps.

Clearly described

Descriptions should explain what a tool does.

They should not read like:

"Revolutionary next-generation AI platform transforming the future of productivity."

That sentence tells me almost nothing.

A boring factual description is much more useful.

Why I still think curated directories matter when AI can search the web

There is an obvious question here.

If AI assistants can search the internet and recommend tools, why maintain a directory manually?

I think search and curation solve different problems.

If I ask:

"What tool can transcribe a meeting?"

search is excellent.

I already know what I need.

But sometimes I want to explore a space.

I want to understand:

• what kinds of AI coding tools exist
• which agent frameworks people are building with
• what options exist for local LLMs
• how many different approaches there are to AI research
• what tools exist next to the one I already know

Search works well when you know the question.

A directory is useful when you are still figuring out what questions to ask.

The searchable version

Eventually I wanted an interface that was easier to browse than one enormous README.

So I built a searchable web version of the catalog:

Browse the searchable Awesome AI Tools directory →

The GitHub repository remains the source of truth.

The website is simply another interface over the same structured catalog.

And because the catalog is structured, there is plenty of room to improve it later without rebuilding the entire project from scratch.

The repository is meant to keep changing

One thing I do not want is for Awesome AI Tools to become a frozen snapshot of the AI ecosystem.

The exact number of tools will change.

Categories may improve.

Old tools may be removed.

Descriptions may become more accurate.

New projects will appear.

That is why the repository is open to community contributions.

If you find:

• a useful AI tool that is missing
• a broken link
• an outdated description
• a dead project
• a better category
• incorrect metadata

you can open an issue or submit a pull request.

Contribute to Awesome AI Tools on GitHub →

I would much rather have the catalog improve through hundreds of small corrections than pretend one person can permanently keep track of the entire AI ecosystem.

What I learned building it

I started this project because I was bad at organizing bookmarks.

The surprising part is that the most interesting problems ended up having very little to do with bookmarks.

They became questions like:

How should information be categorized?

When should a category become a subcategory?

Which metadata is useful enough to maintain?

How do you represent something you do not know?

How do you keep generated documentation in sync with structured data?

When should an old entry be removed instead of preserved?

How do you let people contribute without gradually reducing the quality of the catalog?

In other words:

I thought I was collecting AI tools.

I was actually building a small information system.

And that turned out to be much more interesting.

FAQ

What is Awesome AI Tools?

Awesome AI Tools is an open, curated GitHub directory for discovering AI tools across development, agents, research, automation, productivity, creative work, LLMs, machine learning, and other categories.

The catalog contains hundreds of tools and continues to grow and change through maintenance and community contributions.

Is Awesome AI Tools only for developers?

No.

There are tools for developers, creators, researchers, students, founders, marketers, designers, and people who simply want to improve their workflows with AI.

The developer-focused categories are only one part of the directory.

What kinds of AI tools are included?

The catalog includes areas such as AI coding assistants, AI agents, research tools, LLM frameworks, image and video generation, audio, automation, productivity, business software, machine learning platforms, MLOps, and more.

Is the list open source?

The catalog is maintained publicly on GitHub and accepts issues and pull requests.

The repository itself is available here:

https://github.com/aliammari1/awesome-ai-tools

How can I add an AI tool?

Open an issue or submit a pull request to the repository.

Contributions should use factual descriptions and fit the project's quality and categorization guidelines.

One question for DEV

There is one thing I am still thinking about.

As the catalog grows, I can add more metadata.

Things like:

Open-source status?

API availability?

Self-hosting?

Pricing?

Last verified date?

GitHub activity?

Supported platforms?

A short human-written note about why the tool is interesting?

But every extra field also becomes something that eventually needs to be maintained.

So I would genuinely like to know:

When you are comparing AI tools, what information actually helps you decide whether a tool is worth trying?

If enough people mention the same thing, I will probably add it to the catalog.

You can browse the project here:

GitHub: https://github.com/aliammari1/awesome-ai-tools

Searchable directory: https://docs.aliammari.dev

And if you notice something outdated, opening an issue or pull request is especially welcome.

---

Disclosure: I used ChatGPT to help edit and structure this article. The project, implementation, maintenance decisions, and underlying ideas are my own.