Agentic-Design-Patterns README

The project's README from github.com/evoiz/Agentic-Design-Patterns. As one markdown file: README.md.

📚 Agentic Design Patterns - A Hands-On Guide to Building Intelligent Systems

Book Author Charity License

📖 About This Repository

This repository contains the complete materials for "Agentic Design Patterns: A Hands-On Guide to Building Intelligent Systems" by Antonio Gulli. It includes all chapters in PDF format and accompanying code notebooks for hands-on learning.

Note: All author royalties are donated to Save the Children 💝

🎯 What You'll Learn

This comprehensive guide covers 21 chapters and 7 appendices on building intelligent AI agent systems, including:

📁 Repository Structure

.
├── 📄 README.md                           # This file
├── 📚 book/
│   └── Agentic_Design_Patterns_Complete.pdf  # Complete book (424 pages)
├── 💻 chapter_notebooks/                          # Chapter 
│   ├── Chapter_01_Prompt_Chaining.ipynb
│   ├── Chapter_02_Routing.ipynb
│   ├── Chapter_03_Parallelization.ipynb
│   ├── ...
│   └── Appendix_G_Coding_Agents.ipynb

📚 Table of Contents

Introduction & Foundations

Part One: Core Patterns (103 pages)

  1. Chapter 1: Prompt Chaining - Sequential task decomposition
  2. Chapter 2: Routing - Dynamic path selection
  3. Chapter 3: Parallelization - Concurrent processing
  4. Chapter 4: Reflection - Self-improvement mechanisms
  5. Chapter 5: Tool Use - External capability integration
  6. Chapter 6: Planning - Strategic task management
  7. Chapter 7: Multi-Agent - Collaborative systems

Part Two: Advanced Patterns (61 pages)

  1. Chapter 8: Memory Management - State persistence
  2. Chapter 9: Learning and Adaptation - Dynamic improvement
  3. Chapter 10: Model Context Protocol (MCP) - Standardized interfaces
  4. Chapter 11: Goal Setting and Monitoring - Objective tracking

Part Three: Production Patterns (34 pages)

  1. Chapter 12: Exception Handling and Recovery - Robust error management
  2. Chapter 13: Human-in-the-Loop - Human-AI collaboration
  3. Chapter 14: Knowledge Retrieval (RAG) - Information access patterns

Part Four: Enterprise Patterns (114 pages)

  1. Chapter 15: Inter-Agent Communication (A2A) - Agent networking
  2. Chapter 16: Resource-Aware Optimization - Efficient resource usage
  3. Chapter 17: Reasoning Techniques - Advanced decision-making
  4. Chapter 18: Guardrails/Safety Patterns - Risk mitigation
  5. Chapter 19: Evaluation and Monitoring - Performance tracking
  6. Chapter 20: Prioritization - Task management
  7. Chapter 21: Exploration and Discovery - Autonomous learning

Appendices (74 pages)

Conclusion & References

🚀 Getting Started

Prerequisites

# Python 3.8 or higher required
python --version

# Install Jupyter for notebooks
pip install jupyter notebook

# Install common dependencies
pip install -r requirements.txt

Installation

  1. Clone the repository
git clone https://github.com/evoiz/Agentic-Design-Patterns.git
cd Agentic-Design-Patterns
  1. Set up virtual environment (recommended)
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
  1. Install dependencies
pip install jupyter notebook
pip install pandas numpy matplotlib openai langchain
  1. Launch Jupyter Notebook
jupyter notebook

💻 Running the Code

Each chapter includes a Jupyter notebook with practical examples:

  1. Navigate to the chapter_notebooks/ directory
  2. Open the desired chapter notebook
  3. Follow the instructions within each notebook
  4. Run cells sequentially for best learning experience

Example: Running Chapter 1

# Navigate to notebooks directory
cd chapter_notebooks

# Launch specific notebook
jupyter notebook Chapter_01_Prompt_Chaining.ipynb

📖 How to Use This Repository

For Self-Study

  1. Read each chapter in the PDF
  2. Open the corresponding notebook
  3. Run the code examples
  4. Experiment with modifications
  5. Complete the exercises

For Teaching

  1. Use chapters as lecture materials
  2. Assign notebooks as lab exercises
  3. Create custom examples based on patterns
  4. Build projects using multiple patterns

For Research

  1. Reference implementation patterns
  2. Benchmark different approaches
  3. Extend patterns for new use cases
  4. Contribute improvements back

🤝 Contributing

We welcome contributions! Please see our Contributing Guidelines.

Ways to Contribute

Contribution Process

  1. Fork the repository
  2. Create your feature branch (git checkout -b feature/AmazingFeature)
  3. Commit your changes (git commit -m 'Add some AmazingFeature')
  4. Push to the branch (git push origin feature/AmazingFeature)
  5. Open a Pull Request

📚 Additional Resources

Learning Path

  1. Beginners: Start with Chapters 1-7 (Core Patterns)
  2. Intermediate: Progress through Chapters 8-14 (Advanced & Production)
  3. Advanced: Master Chapters 15-21 (Enterprise Patterns)
  4. Experts: Explore Appendices for cutting-edge techniques

⚖️ License

This repository is for educational purposes. Please respect the author's copyright and intellectual property rights.

🙏 Acknowledgments

📞 Contact & Support

🌟 Star History

If you find this repository useful, please consider giving it a star ⭐

Star History Chart

📊 Repository Stats

GitHub last commit GitHub issues GitHub pull requests GitHub

Building the future of AI, one pattern at a time 🚀

Made with ❤️ for the AI community

Agentic-Design-Patterns (evoiz/Agentic-Design-Patterns)

Searching Database…

3.9K ·GitHub
Agentic-Design-Patterns
What is this?The complete companion materials for Antonio Gulli's book 'Agentic Design Patterns: A Hands-On Guide to Building Intelligent Systems' — all 21 chapters as PDFs plus matching Jupyter code notebooks.
Is it just the book text, or can I run code too?Both: every chapter ships as a PDF for reading plus a Jupyter notebook in the chapternotebooks/ directory with practical examples you run cell by cell.
How do I get the notebooks running?Clone the repository, set up a virtual environment (recommended), install the dependencies and launch Jupyter Notebook; then open a chapter notebook from chapternotebooks/ and run the cells sequentially.
Is it usable for teaching or research, or just self-study?All three: chapters can serve as lecture materials, notebooks as lab exercises, and researchers can reference the implementations to benchmark approaches or extend patterns to new use cases.
Can I copy and redistribute the materials?Not fully: the book content is copyrighted by Antonio Gulli with all rights reserved, while the code examples are MIT-licensed and educational use is permitted with attribution.
How long is the book?The table of contents lists 103 pages for the core patterns part, 61 for advanced patterns, 34 for production patterns and 114 for enterprise patterns, plus 74 pages of appendices.
Does it get hands-on with specific agent frameworks?Appendix C is a quick overview of agentic frameworks, Appendix D builds an agent with AgentSpace, Appendix E covers AI agents on the CLI and Appendix G covers coding agents; LangChain, AutoGPT, OpenAI Assistants, Microsoft AutoGen and CrewAI are listed as related frameworks.
What is MCP in this book?The Model Context Protocol, covered in Chapter 10 as a standardized-interface pattern; the book places it among the advanced patterns alongside memory management and goal setting.
Does the author make money from it?All author royalties from the book are donated to Save the Children.
What are similar projects?ai-agents-the-definitive-guide, ai-system-design, ai-agent-book, Agent-Learning-Hub, CV, ai-engineering-from-scratch, production-agentic-rag-course, ai-guide
Which topics is it in?design-patterns, ebook, autonomous-agents, course, jupyter notebook, prompt-engineering, book, artificial-intelligence, pdf, rag, agentic-ai, guide
Creator
evoiz
Size
3.3 MB
Stars
3.9K
Updated
CommitJul 24
Age
1y
Commits · 90 Days