Welcome to the 100x Applied AI repository! This is a comprehensive resource for learning and implementing Large Language Model (LLM) & Agentic applications. Whether you're a complete beginner or looking to enhance your AI engineering skills, this guide will help you navigate through practical implementations.
- What is this Repository?
- Who is this for?
- Prerequisites
- Quick Start Guide
- Repository Structure
- Learning Path
- Example Projects
- Troubleshooting
- Contributing
This repository contains 140+ practical implementations from the 100x Applied AI cohort, covering:
- Full-Stack AI Applications: Build complete AI-powered applications
- Prompt Engineering: Master the art of communicating with AI models
- Tool Calling: Connect LLMs to external tools and APIs
- RAG (Retrieval Augmented Generation): Build AI systems that can search and use your own data
- LLM Workflows: Learn how to orchestrate AI models for complex tasks
- AI Agents: Create autonomous AI systems that can reason and take actions
Key Technologies: OpenAI, Groq, Hugging Face, LlamaIndex, FastAPI, Streamlit
- Beginners: Each section includes detailed explanations and step-by-step guides
- Developers: Ready-to-use code snippets and API implementations
- AI Enthusiasts: Learn modern AI patterns and best practices
- Basic Python: Understanding of functions, classes, and modules
- Command Line: Basic terminal/command prompt usage
- APIs (Optional): Helpful but not required
- Python 3.8 or higher (Download here)
- pip (comes with Python)
- Git (Download here)
- Text Editor (VS Code, Cursor, PyCharm etc)
You'll need at least one of these (most have free tiers):
- OpenAI API Key (Get it here) - Most examples use this
- Groq API Key (Get it here) - Free and fast alternative
- Hugging Face Token (Get it here) - For open-source models
# Open your terminal and run:
git clone https://github.com/Siddhant-Goswami/open-source-project.git
cd open-source-project# Create a virtual environment (keeps dependencies isolated)
python -m venv venv
# Activate the virtual environment
# On Mac/Linux:
source venv/bin/activate
# On Windows:
venv\Scripts\activate
# You should see (venv) in your terminal now# Install all required packages (this may take a few minutes)
pip install -r requirements.txt# Create your environment file
cp .env_example .env
# Open .env in your text editor and add your API keys:
# OPENAI_API_KEY=sk-your-key-here
# GROQ_API_KEY=your-groq-key-here
# HUGGINGFACE_API_KEY=your-hf-key-here# Try running a simple example
python llm_workflows/prompt_chaining.pyIf you see output without errors, congratulations! You're ready to start learning.
Complete applications combining AI with web interfaces. Start here to see how everything comes together!
What you'll learn:
- Building APIs with FastAPI
- Creating UIs with Streamlit and Gradio
- Authentication (Auth0 integration)
- Email integration
- Database management
Available Apps:
ai_crm/- AI-powered Customer Relationship Managementauth/- Authentication systemapi/- RESTful API examples
Start here: llm_full_stack/api/app.py
Example use case: Build a customer support chatbot with user authentication
28 specialized prompt templates for different roles and use cases. Master the art of communicating with AI!
Available Prompts:
ai_cmo.md- Chief Marketing Officer promptsai_cto.md- Chief Technology Officer promptsbusiness_coach.md- Business coaching promptsproduct_manager.md- Product management promptslinkedin_content.md- Social media content creation- And 23 more specialized prompts!
Start here: Browse the prompts/ directory
Example use case: Generate professional LinkedIn posts or get technical advice
Connect LLMs to external tools, APIs, and databases to extend their capabilities.
What you'll learn:
- Defining functions that LLMs can call
- Handling function calls and responses
- Building tools for different providers (OpenAI, Groq, Llama)
Start here: tool_calling/gpt_function_calling.py
Example use case: Build a weather bot that can check real-time weather data
Retrieval Augmented Generation lets AI models access and use your own documents.
What you'll learn:
- Level 1: Using OpenAI's File Search API (easiest)
- Level 2: LlamaIndex integration (more control)
Start here: rag/openai_file_search.py
Example use case: Build a chatbot that answers questions about your company's documentation
Build RAG systems from scratch with complete control over the retrieval process.
What you'll learn:
- Creating embeddings (vector representations of text)
- Storing vectors in Supabase
- Semantic search (finding similar content)
- Custom retrieval strategies
Start here: rag_advanced/rag_from_scratch.py
Example use case: Build a research assistant that searches through academic papers
Learn how to chain multiple LLM calls together for complex, multi-step tasks.
What you'll learn:
- Prompt chaining: Breaking complex tasks into steps
- Router patterns: Directing requests to appropriate handlers
- Parallel processing: Running multiple AI tasks simultaneously
- Code review automation: Using AI to review code
Start here: llm_workflows/prompt_chaining.py
Example use case: Automatically generate marketing copy with brand consistency checks
Autonomous AI systems that can reason, plan, and take actions to accomplish complex goals.
What you'll learn:
- ReAct Pattern: Reasoning + Acting loop (agents that think before acting)
- Research Agents: Agents that can search and analyze web content
- Reflection Pattern: Agents that improve through self-evaluation
Available Agents:
trip_planner/- Plan complete trips with itinerariesjob-posting/- Generate and optimize job descriptionsreact_patterns/- Learn the ReAct reasoning framework
Start here: agents/react_patterns/react_v0.py
Example use case: Build a travel planning agent that researches destinations and creates itineraries
Work with open-source models and the Hugging Face ecosystem.
What you'll learn:
- Using transformer models
- Image segmentation
- Chat completions with open-source models
- Model inference
Start here: huggingface/chat_completion.py
Follow this structured 6-week roadmap to go from zero to building AI applications:
- Week 1 - Prompt Engineering: Start by exploring the
prompts/directory to learn how to communicate effectively with AI models - Week 2 - Full-Stack Applications: Run
llm_full_stack/api/app.pyto see complete AI applications in action - Week 3 - Tool Calling: Try
tool_calling/gpt_function_calling.pyto learn how to extend LLM capabilities with external tools - Week 4 - RAG Systems: Build
rag/openai_file_search.pyto create AI that can search your own documents - Week 5 - LLM Workflows: Explore
llm_workflows/prompt_chaining.pyto orchestrate complex multi-step AI tasks - Week 6 - AI Agents: Build your first autonomous agent with
agents/react_patterns/react_v0.py
Jump straight into building with this accelerated path:
- Full-Stack Applications: Start with
llm_full_stack/api/app.pyto understand complete AI systems - Prompt Engineering: Master
prompts/to optimize AI interactions - Tool Calling: Integrate external APIs with
tool_calling/gpt_function_calling.py - Advanced RAG: Build custom retrieval systems with
rag_advanced/rag_from_scratch.py - LLM Workflows: Create complex orchestrations in
llm_workflows/ - Multi-Agent Systems: Explore
agents/for collaborative AI agents
Deep dive into advanced patterns and build production systems:
- Full-Stack Integration: Combine all patterns in
llm_full_stack/with authentication and databases - Custom Workflows: Build sophisticated orchestration in
llm_workflows/ - Advanced Agents: Explore
agents/reflection.pyfor self-improving agent patterns - Production RAG: Implement enterprise-grade retrieval with
rag_advanced/and Supabase - Multi-Agent Orchestration: Build teams of specialized agents
Start with these hands-on projects that follow the learning path:
# Navigate to full-stack directory
cd llm_full_stack/api
# Run the FastAPI + Gradio application
python app.py
# What this does:
# 1. Starts a FastAPI server with AI endpoints
# 2. Launches a Gradio UI for interaction
# 3. Shows how to integrate AI into web applications# Navigate to tool calling directory
cd tool_calling
# Run the GPT function calling example
python gpt_function_calling.py
# What this does:
# 1. Connects LLM to external weather API
# 2. Handles function calls dynamically
# 3. Returns real-time weather data through AI# Navigate to RAG directory
cd rag
# Run the OpenAI file search example
python openai_file_search.py
# What this does:
# 1. Uploads your documents to vector storage
# 2. Creates a searchable knowledge base
# 3. Answers questions using your own data# Navigate to workflows directory
cd llm_workflows
# Run the prompt chaining app
python prompt_chaining_app.py
# What this does:
# 1. Generates marketing copy with AI
# 2. Reviews and checks brand consistency
# 3. Optimizes content for engagement# Navigate to agents directory
cd agents/trip_planner
# Run the autonomous trip planner
python main.py
# What this does:
# 1. Takes your destination and travel preferences
# 2. Researches activities, hotels, and restaurants
# 3. Creates a complete day-by-day itinerarySolution:
# Make sure your virtual environment is activated
source venv/bin/activate # Mac/Linux
venv\Scripts\activate # Windows
# Reinstall dependencies
pip install -r requirements.txtSolution:
# Check your .env file exists
ls -la .env
# Make sure it contains your API keys
cat .env
# The format should be:
# OPENAI_API_KEY=sk-...
# No spaces around the = sign!Solution:
- You've hit your API quota
- Wait a few minutes or upgrade your API plan
- Try using Groq API (usually more generous free tier)
Solution:
- Check your internet connection
- Some corporate networks block API calls
- Try using a personal network or VPN
- Check individual directory README files
- Review the code comments (they're detailed!)
- Open an issue on GitHub
Create a .env file in the root directory with the following:
# Required for most examples
OPENAI_API_KEY=sk-your-openai-key-here
# Optional: For alternative LLM providers
GROQ_API_KEY=your-groq-key-here
# Optional: For Hugging Face models
HUGGINGFACE_API_KEY=your-huggingface-token-here
# Optional: For RAG with Supabase
SUPABASE_URL=your-supabase-url
SUPABASE_KEY=your-supabase-key
# Optional: For Notion integration
NOTION_TOKEN=your-notion-token-here
# Optional: For Auth0
AUTH0_DOMAIN=your-auth0-domain
AUTH0_CLIENT_ID=your-client-id
AUTH0_CLIENT_SECRET=your-client-secretLarge Language Model - AI trained on vast amounts of text that can understand and generate human-like text.
Retrieval Augmented Generation - Giving LLMs access to your specific documents/data so they can answer questions about your content.
An autonomous system that can reason, plan, and take actions to accomplish goals (like a virtual assistant).
Allowing LLMs to use external tools, APIs, and databases to get real-time information or take actions.
The art and science of crafting instructions (prompts) to get the best results from AI models.
| Technology | Purpose | Learn More |
|---|---|---|
| OpenAI | GPT models for text generation | docs.openai.com |
| Groq | Fast inference for LLMs | console.groq.com |
| LlamaIndex | RAG framework | docs.llamaindex.ai |
| FastAPI | Modern Python web framework | fastapi.tiangolo.com |
| Streamlit | Data app framework | streamlit.io |
| Supabase | Database and vector storage | supabase.com |
- Pick a project from the Example Projects section
- Follow the code - Each file has detailed comments
- Modify and experiment - Change prompts, try different models
- Build something new - Combine different patterns
- Share your work - Contribute back to the community!
We welcome contributions! Here's how:
- Fork the repository (click "Fork" button on GitHub)
- Create a feature branch
git checkout -b feature/your-feature-name
- Make your changes and commit
git commit -m "Add: Description of your changes" - Push to your fork
git push origin feature/your-feature-name
- Create a Pull Request on GitHub
- Add more examples
- Improve documentation
- Fix bugs
- Add tests
- Create tutorial videos
This project is open-source. Check the LICENSE file for details.
- Issues: GitHub Issues
- Discussions: Use GitHub Discussions for questions
- Updates: Watch the repository for updates
Built with ❤️ for 100xEngineers, by 100xEngineers.
