100x-LLM: Applied AI Code Examples from the 100x Engineers Cohort

A cohort code archive for LLM pattern learners

The 100x-LLM repository is the public output of the 100x Engineers Applied AI cohort. Its stated purpose is to give cohort participants and anyone following along a working reference for building with large language models and the infrastructure around them. The README describes it as a comprehensive resource for both beginners learning LLMs for the first time and developers who want to extend existing skills into AI-powered applications.

The intended audience is specific: Python developers who can write functions and classes, who are comfortable with the command line, and who can obtain at least one free-tier API key from OpenAI, Groq, or Hugging Face. Researchers needing production-ready code with stable APIs, test coverage, and version guarantees will find this repository does not serve that need. Every file is a standalone script or template, not an installable package.

At its core the repository is a pattern index. Each example shows one specific way to connect Python code to language model APIs, from basic prompt chaining to multi-step autonomous agents. The README states the collection holds 140+ implementations across seven top-level directories. The breadth is a real strength for learners and also a real limitation: with so many examples and no unifying framework, readers must judge for themselves which patterns match their actual problem and whether a given script still works with current library versions.

What 140+ implementations covers across seven directories

The repository tree has seven substantive directories, each mapping to a distinct engineering concern.

`llm_full_stack/` holds complete applications. It combines FastAPI backends with Streamlit and Gradio frontends, an Auth0-based authentication system, and an AI-powered CRM prototype. This directory demonstrates how the AI call sits inside a real web stack rather than a standalone script.

`prompts/` contains 28 Markdown files covering specialized roles: ai_cmo.md, ai_cto.md, business_coach.md, product_manager.md, linkedin_content.md, and 23 more. These are text templates, not executable code. Using them requires manually copying content into a chat interface or writing a loader.

`tool_calling/` demonstrates how to define Python functions that language models can invoke, with implementations targeting OpenAI, Groq, and Llama providers. The README names `tool_calling/gpt_function_calling.py` as the starting file.

The RAG material splits across two directories. `rag/` offers two levels: level one uses OpenAI's File Search API, level two adds LlamaIndex integration and more control over retrieval. `rag_advanced/` builds retrieval from scratch by creating text embeddings, storing them as vectors in Supabase, and running semantic search to retrieve relevant chunks before the model sees them. The starting file for the advanced path is `rag_advanced/rag_from_scratch.py`.

`llm_workflows/` addresses chaining multiple model calls for complex tasks. The README describes four sub-patterns: prompt chaining, a router that directs requests to appropriate handlers, parallel processing across multiple LLM calls, and automated code review. The starting file is `llm_workflows/prompt_chaining.py`.

`agents/` implements the ReAct pattern, where the model alternates between a reasoning step and an action step. The directory also includes a research agent that can search web content and a reflection pattern where agents critique and revise their own output.

Setting up the environment and running the first script

The README describes a five-step setup. The first step clones the repository:

git clone https://github.com/Siddhant-Goswami/open-source-project.git
cd open-source-project

The second step creates an isolated Python virtual environment and activates it. On macOS and Linux:

python -m venv venv
source venv/bin/activate

The third step installs all required packages from the pinned requirements file:

pip install -r requirements.txt

This installs over 100 packages including openai==1.23.6, llama-index==0.10.36, fastapi==0.111.0, groq==0.4.2, and streamlit. Expect several minutes for the install to finish. The fourth step creates the local environment file from the provided example and adds an API key:

cp .env_example .env

Open the resulting .env in a text editor and add at least OPENAI_API_KEY or GROQ_API_KEY. Most examples use OpenAI; Groq provides a free alternative for LLM calls. The fifth step, once a key is configured, runs a sample script to confirm setup:

python llm_workflows/prompt_chaining.py

If the output arrives without errors, the environment is ready. Each directory section of the README names its own recommended starting file, so the same pattern applies when exploring other topics.

Advanced RAG and the ReAct agent pattern in detail

The advanced RAG section is the most technically demanding part of the repository. Unlike the basic RAG path that relies on OpenAI's managed file search, the advanced version requires setting up a Supabase project, configuring its vector storage layer, and running an embedding pipeline to index documents before any queries can be answered. The README describes the flow as: generate embeddings from documents, store the resulting vectors in Supabase, then run semantic search to retrieve the most relevant chunks before passing them to the model. The starting file is `rag_advanced/rag_from_scratch.py`.

This approach exposes each step of the retrieval pipeline directly, which matters for developers who need to understand or modify the retrieval strategy. The trade-off is meaningful additional infrastructure: Supabase requires an account and a configured project, and SUPABASE_URL plus SUPABASE_ANON_KEY must be added to .env before the scripts work. This adds setup time that the level-one RAG path avoids entirely.

The agent implementations in `agents/` centre on the ReAct pattern, which the README describes as a Reasoning plus Acting loop: the model reasons about what to do next, takes an action such as a web search or function call, then reasons about the result before deciding on the next step. This is the core of most task-completing agents. The research agent variant extends the loop with live web search capability. The reflection variant adds a self-critique step, where the agent evaluates its own output and revises it. Both variants use the same provider and API key configured during setup.

Limitations to know before adopting these patterns

The repository is a collection of examples, not a tested library. The top-level entries include no visible test directory, no CI configuration visible at the root, and no published package on PyPI. Code that ran correctly at the time of writing may behave differently today because requirements.txt pins packages to their 2024 release versions. For example, openai==1.23.6 is far behind the current OpenAI Python SDK, and the LlamaIndex API changed substantially between its 0.10.x series and later releases. A developer cloning this repository in 2026 should expect to resolve version conflicts if they need newer API features.

The 28 prompt templates in `prompts/` have no execution mechanism in the repository. Using them requires either copying content manually into a chat interface or writing custom code to load the Markdown files and pass them to the model. There is no built-in runner.

Several integrations also require paid services or rate-limited accounts. OpenAI charges per token, Supabase has a storage-limited free tier, and the Hugging Face inference API has its own quota. Groq offers a free alternative for the LLM call itself, but the advanced RAG and full-stack application examples have no Groq equivalent and rely on OpenAI.

The README does not document what happens when API rate limits are hit, how to handle partial failures in parallel LLM workflow runs, or recovery strategies for multi-step agent executions. These are not criticisms of the cohort material but constraints on how the repository can be used as a production reference.

How this compares to the LangChain cookbook

The most common alternative for applied LLM code examples is the LangChain cookbook, which provides runnable Python examples for similar patterns. The key architectural difference is that LangChain examples route all provider calls through LangChain's abstraction layer, making them portable across providers without changing the calling code. The 100x-LLM examples call provider APIs more directly, using the openai and groq packages without an intermediate routing layer.

For a developer who wants to understand how OpenAI's tool-calling API actually works at the HTTP level, the 100x-LLM examples are more transparent. For a developer who needs patterns that switch between OpenAI and Anthropic without changing signatures, LangChain's approach is more portable.

The 100x-LLM repository also covers full-stack application shells in `llm_full_stack/` that combine FastAPI, Streamlit, Gradio, and Auth0. This scope, working code for authenticated web apps with an AI layer, is not covered in most LLM cookbooks. The LangChain cookbook focuses on the LLM interaction layer and does not ship authenticated application shells.

Maintenance status and licence

The last push to the repository was on 2026-08-04. The project is not archived. There are no GitHub releases; updates appear to land directly on the main branch.

The repository is available under the MIT licence, which permits use, modification, and redistribution without requiring that derivative works carry the same licence.

The requirements.txt pins specific package versions rather than ranges. The lock is strong, but the pinned versions have fallen behind the current releases of openai, LlamaIndex, and several other libraries in the stack. Anyone running the scripts today should expect to spend time resolving version conflicts if they need to upgrade any component of the stack.

Editorial conclusion

Developers learning applied LLM engineering will find this repository a useful reference for concrete patterns they can run and adapt. Teams looking for a tested, installable library with stable APIs and error handling should look elsewhere. Before cloning, confirm you have Python 3.8 or higher and at least one active API key from OpenAI, Groq, or Hugging Face, since most scripts will fail without one.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. Project website
4. README
5. Siddhant-Goswami/100x-LLM on GitHub