convez.ai
MCP ServerDesenvolvimento WebIntermediário
SreeGD

AgenticCourse

SreeGD/AgenticCourse

Aprenda IA agentica do zero até sistemas complexos com exemplos executáveis

Ver no GitHub
InicialPluginScore · de 0 a 100

Currículo hands-on completo para construir sistemas de IA agentica com LangChain, LangGraph e Claude. Inclui 21 exemplos executáveis, 72 testes e 17 lições que cobrem desde invocações básicas até RAG multi-agente com cache, memória e guardrails em produção.

Instalação

$npx convez-ai SreeGD/AgenticCourse

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
1
Forks
0
Acompanhando
0
Saúde
42%
Último commit
há 3 semanas
Versão
—
Issues abertas
1
Contribuidores
1

Casos de uso

  • Aprender arquitetura de agentes com Claude e LangGraph
  • Implementar RAG com caching e memória stateful
  • Construir sistemas multi-agente com Reflection e Plan-and-Execute
  • Dominar MCP servers e Claude Skills para modularização

Veredito

Recurso educacional robusto e bem-estruturado para quem quer dominar IA agentica em produção. A progressão incremental (40 sessões, 21 exemplos executáveis, 72 testes) torna viável o aprendizado de conceitos complexos; ideal para engenheiros que já conhecem Python e querem ir além de chatbots triviais.

README

A tradução para o português deste README ainda está na fila.

AgenticCourse

A hands-on curriculum for building agentic AI systems with LangChain, LangGraph, and Anthropic Claude — from a one-line model.invoke() to a multi-agent, RAG-grounded, cached, guardrailed, memory-having production chatbot, plus the patterns above and beyond (Reflection, Plan-and-Execute, MCP, Spec-Driven Development, Vibe Coding, Claude Skills, and more).

Built incrementally as a learning project. Every file in labs/ is a runnable example that adds exactly one concept on top of the previous one.

License: MIT Python 3.10+ Tests: 72 passing


Where to start

GoalGo to
See the codelabs/ — 21+ runnable Python examples
Read the lessonslabs/lessons/ — per-topic walkthroughs with FAQ
Conceptual deep diveslabs/LEARNINGS.md
Full 40-session learning planlabs/CURRICULUM.md + labs/CURRICULUM.csv
Run somethingQuick start below
Run the testsTesting below

What's in labs/

Each file teaches one concept and runs standalone. Files are prefixed with their lesson number for discoverability.

Phase 1 — Foundation (lessons 01–12)

FileConcept
01_model_wrapper.pyModel wrapper — ChatAnthropic.invoke()
02_lcel_chain.pyLCEL composition — prompt | model | parser
03_agent_manual.pyManual tool-calling loop (hand-written while not msg.tool_calls)
03_agent_framework.pyFramework agent — create_react_agent from LangGraph
04_prompt_caching.pyPrompt caching — 76% cheaper per run with one keyword
05_structured_output.pyTyped output — model.with_structured_output(PydanticModel)
06_parallel_chains.pyLCEL fan-out — RunnableParallel
07_output_parsers.pySix built-in output parsers + a custom one
08_chatbot_memory.pyStateful agent — MemorySaver + thread_id
09_rag.pyFull RAG pipeline — load → split → embed → store → retrieve → generate
10_guardrails.pyRAG wrapped in input + output guardrails
11_production_chatbot.pyCapstone — RAG + memory + caching + guardrails composed

Phase 2 — Advanced patterns (sessions 1–6 of the 40-session curriculum)

FileConcept
12_mcp_server.py + 12_mcp_client.pyMCP — tools shared via JSON-RPC stdio, usable by any MCP client
13_reflection_agent.pyReflection — writer + critic loop with iteration budget
13_plan_execute_agent.pyPlan-and-Execute — planner + executor + aggregator
14_multi_agent.pySupervisor + specialists pattern
14_long_term_memory.pyVector-stored user facts across sessions
15_spec_driven.pySpec-Driven Development — Spec → Tasks → Code → VerificationReport
16_vibe_coding.pyVibe Coding — generate → execute → reflect → retry
17_claude_skills_router.py + skills/*/SKILL.mdClaude Skills — modular knowledge bundles with description-based triggering

Plus:


The curriculum at a glance

40 sessions across 13 tracks, ~80 hours, ~13 weeks at 9 hours/week.

PhaseSessionsTracks
Foundation1-17Agentic Patterns • Workflow & Skill • Alt Architectures • Data/Multi-modal • Graph Depth • RAG Architectures • Production
Architect Skills18-21System Design Interview • Red-teaming • Governance & Audit • AI Product UX
Vertical Deep Dives22-37Healthcare • Agriculture • Finance • Vidya Karana (wellness/yoga/Vedic) • Family AI Agent
Claude Code Mastery (optional)38-40CLAUDE.md best practices • Hooks • Autonomous workflows

See labs/CURRICULUM.md for the full session-by-session plan.


Quick start

git clone https://github.com/SreeGD/AgenticCourse.git
cd AgenticCourse/labs

# Create a Python 3.10+ venv (3.11+ recommended for the mcp SDK)
python3.11 -m venv .venv
source .venv/bin/activate

# Install dependencies (first run pulls torch via sentence-transformers; ~5 min)
pip install -r requirements.txt

# Add your Anthropic API key
cp .env.example .env
# edit .env and set ANTHROPIC_API_KEY=sk-ant-...

# Run any example
python 01_model_wrapper.py            # one prompt
python 02_lcel_chain.py               # LCEL chain
python 03_agent_framework.py          # framework agent
python 09_rag.py                      # full RAG pipeline
python 11_production_chatbot.py       # the capstone
python 12_mcp_client.py               # MCP demo
python 15_spec_driven.py              # spec-driven dev
python 16_vibe_coding.py              # vibe coding
python 17_claude_skills_router.py     # skills triggering

Get an Anthropic API key at https://console.anthropic.com.


Testing

A pytest test suite covers the deterministic parts of each session (PII regex, prompt-injection patterns, Pydantic schemas, sandbox helpers, skill frontmatter parsing, curriculum integrity).

cd labs
source .venv/bin/activate
python -m pytest          # → 72 passed in ~3s

Real-LLM integration tests are marked @pytest.mark.integration and skipped by default. Run them with pytest -m integration (requires ANTHROPIC_API_KEY).


Tech stack

  • Models: Anthropic Claude (Sonnet 4.6, Opus 4.7)
  • Framework: LangChain (LCEL), LangGraph (agents, state machines)
  • Embeddings: sentence-transformers/all-MiniLM-L6-v2 (local, free)
  • Vector store: InMemoryVectorStore (swap for FAISS / Chroma / pgvector in production)
  • Tool protocol: MCP (Model Context Protocol)
  • Skills: Claude Skills (SKILL.md with YAML frontmatter)
  • Testing: pytest with structural + unit coverage
  • Python: 3.10+ (3.11+ recommended)

See labs/requirements.txt for the full dependency list.


Key mental models

The seven one-liners that compress the curriculum:

  1. The LLM never calls anything. The LLM Client does. (Tool calling, MCP, agents — all variations of one dance.)
  2. A prompt is the input. A prompt template is a recipe for building a prompt.
  3. An output parser adapts text (what the LLM emits) into typed values (what your code wants).
  4. prompt | model | parser is sequential. {"a": chain_a, "b": chain_b} is parallel.
  5. Each turn carries the whole conversation. Memory adds state. Caching keeps cost bounded.
  6. The cache discount is real because the server skips prefill — the most expensive 80% of inference — not because Anthropic is being nice.
  7. RAG = "I pick the right text client-side, the LLM reads only that text."

Full discussion in labs/LEARNINGS.md.


Status

Active learning project. Phase 1 foundation (lessons 01–12) and Sessions 1–6 of the new curriculum are complete: ~22 runnable Python files, 17 lesson walkthroughs with FAQs, 3 Claude skills, 72 passing tests. The remaining 34 sessions (7 onwards — alt architectures, RAG architectures, production, architect skills, vertical deep dives, Claude Code mastery) are planned in labs/CURRICULUM.md and will be built session by session.

This repo is built and maintained by Sree (@SreeGD) — a data scientist learning agentic AI architecture session by session.


Contributing

Issues and PRs welcome. Two principles to keep the codebase coherent:

  • Each file teaches one concept. Don't combine unrelated patterns in one example.
  • Tests for deterministic logic. LLM-dependent code is best-effort; regex/sandbox/Pydantic logic must have tests.

License

MIT — use freely, attribute kindly.

Ver o original no GitHub

Bom para

Relacionados