Hands-On AI Engineering: A Multi-Project Python Collection for RAG, Agents and OCR

What the repository actually is, and what it is not

The README describes a curated collection of practical, production-ready AI projects across language models, multimodal models, OCR systems, RAG pipelines and AI agents. Read that as a set of independent example directories, not as a framework. There is no top-level package, no importable module, no shared runtime. The repository layout under ai_agents/ holds one folder per project: research_assistant_with_memory, multi_agent_financial_analyst, finagent, daily-news-digest, agentic-form-filler, ai_travel_planning_agent, competitive_intelligence_agent, multi_agent_research_assistant_ag2, agentic_rag_system, agentic_sql_search, stock_portfolio_analyst, eagle_eye, ai_customer_support_agent, multi_agent_coding_assistant, startup_analyst, research_team, github_intelligence_agent, smolagents_code_agent, agent_discovery_agent, cal_scheduling_agent, hacker_news_newsletter_agent, hotel_finder_agent, marketing_strategy_agent and brand_monitor_agent. The README also names OCR and RAG as categories, though the truncated table of contents shows the agent list in most detail. The intended reader is someone who wants to see how a planner/researcher/writer/critic loop is wired up in real code, or how a LangGraph self-reflective RAG pipeline grades its own retrieved context. It is a learning and reference corpus. The word production-ready in the README refers to the individual projects following practices that can be adapted, not to the repository being production infrastructure.

The agent projects and the model providers they bind you to

The collection is unusual in how many different vendors it touches. The README lists OpenAI, Anthropic, Google and open-source models as providers, and the individual entries name specific ones: MiniMax M2.7 for the Daily AI News Digest and Agentic Form Filler, MiniMax M2.5 for Startup Analyst and Research Team, Mistral Small 4 for CartMate, the Multi-Agent Coding Assistant and the Smolagents Code Agent, Gemma 4 for Agentic SQL Search and the Hacker News Newsletter Agent, Gemini 3 Flash for the GitHub Intelligence Agent and Agent Discovery Agent, DeepSeek-V4-Flash via Orq.ai for the Stock Portfolio Analyst and Marketing Strategy Agent, and qwen3.6-flash via Orq.ai for the Hotel Finder Agent. That spread is the point and the problem. Each directory assumes a different account, a different key and a different SDK version. The Multi-Agent Research Assistant with Memory is the one entry the README describes as fully local, running via Ollama with BGE embeddings and an Actian VectorAI DB memory layer. If you want to avoid vendor accounts entirely, that project is the only one the README positions that way. Everything else needs at least one external API credential before the first line of agent logic executes.

How a single project is put together: the multi-agent memory example

The clearest architecture description in the README belongs to the Multi-Agent Research Assistant with Memory. It defines four roles: a Planner, a Research agent, a Writer and a Critic. They collaborate over a shared memory layer backed by Actian VectorAI DB. The flow the README gives is retrieval from PDFs, papers, manuals and transcripts, then a Critic feedback loop that self-grades the drafted answer, then persistence of findings across sessions. That is a retrieve, draft, grade, retain cycle, and the memory store is doing two jobs at once: it holds the source corpus for retrieval and it holds prior session findings so the next run starts warmer. The Critic stage is what distinguishes this from a plain RAG chain, because a failing grade can send the draft back rather than out. The Self-Reflective Agentic RAG entry in the same directory takes a related but narrower approach with LangGraph: it grades retrieved context, rewrites the query if the context fails validation, and only then generates an answer. The difference matters. The memory assistant grades the output and keeps state across sessions; the LangGraph system grades the input and rewrites before generation. Both are described in the README, neither is benchmarked there.

Getting a project running: what the README does and does not give you

The README has a Getting Started section in its table of contents, but the supplied text does not include its contents. So there is no verified install command to quote here. What can be said from the material is the shape of the setup each project implies: you clone the repository, change into the relevant subdirectory such as ai_agents/research_assistant_with_memory or ai_agents/agentic_rag_system, and follow that directory's own instructions, because the top-level README does not carry per-project configuration. The credentials you will need depend on the project. A project built on Orq.ai needs an Orq.ai key. The GitHub Intelligence Agent uses GitHub's official MCP server, which implies a GitHub token. The Eagle Eye PR review agent fetches diffs via GitHub MCP and posts to Telegram, so it needs both. The Cal Scheduling Agent manages Cal.com appointments and needs Cal.com access. The Hacker News Newsletter Agent delivers via Gmail SMTP, which means an app password or equivalent. For the local memory assistant, the README specifies Ollama and BGE embeddings, so those are the two components to install before the agents can run. Treat any config key you find as belonging to one project only; do not assume it is shared.

The collection format is the limitation

A repository of two dozen independent projects has no single version to pin, no changelog that covers all of them, and no guarantee that a fix in one directory reaches another. The README states there are regular updates and new project additions, and the last push date is recent, but there are no releases retrieved for this repository, which means there is no tagged version you can depend on. If a model provider renames a model or retires an endpoint, the affected projects break individually and silently. The README already illustrates how fast this moves: it names MiniMax M2.5 and M2.7, DeepSeek-V4-Flash, Mistral Small 4, Gemma 4, Gemini 3 Flash and qwen3.6-flash. Those version numbers are baked into project code and prose, and each one is a future maintenance task. The licence situation is a second constraint. The README carries an MIT badge and a License section, and the description field for the repository says the licence is unknown. Those two signals disagree. The badge points at opensource.org, but the badge is not the licence file. If you intend to reuse code from a subdirectory in a commercial product, read the actual LICENSE file in the repository rather than the badge. This is not legal advice; it is a statement that the two sources in the supplied material do not match.

How it compares with LangChain templates and LlamaIndex examples

The closest comparison is the example gallery maintained by an agent framework itself, such as the LangChain template collection or the LlamaIndex example notebooks. Those are organised around one framework's abstractions, so every example imports the same core classes and upgrading the framework upgrades the whole set. Hands-On-AI-Engineering is organised the opposite way. The README shows projects built on LangGraph, AG2, Agno, LangChain, HuggingFace smolagents and plain vendor SDKs, with no shared abstraction layer. The trade-off is direct: you get breadth across frameworks and providers, and you give up the ability to upgrade everything at once. If you are already committed to LangGraph, the Self-Reflective Agentic RAG project is the one to read, and the rest of the collection is a source of patterns rather than code you can drop in. If you are still choosing a framework, the collection lets you compare how the same multi-agent idea looks in AG2 versus smolagents versus a hand-rolled planner/critic loop, which a single-framework gallery cannot show you.

Who should clone it and what to check first

Clone it if you learn by reading working code and you want to see concrete implementations of a critic feedback loop, a query-rewriting RAG graph, or an MCP-backed review agent. The Multi-Agent Research Assistant with Memory is the strongest entry for that purpose because the README describes its full data flow and because it is the one project positioned as fully local. Do not clone it expecting a maintained dependency, a unified CLI, or a single set of pinned versions. Before you invest time in any one directory, verify three things in that directory itself: the requirements or dependency file, the environment variables the code reads, and whether the model names in the README still exist at the provider. The top-level README will not answer any of those questions, and the licence badge will not tell you what the LICENSE file says.

Editorial conclusion

Adopt it if you want a reference implementation to copy from, not a dependency to build on. Skip it if you need a single supported package, pinned versions, or a maintained API surface. Before cloning anything, open the specific subdirectory you care about and check its own README, requirements file and licence header, because the top-level README does not tell you which model providers, keys or paid services that project needs.

Official sources

1. Issues
2. Project website
3. README
4. Sumanth077/Hands-On-AI-Engineering on GitHub