Agentic AI

GenAI: Deploying Agentic AI Architectures

540 ore de studiu

72 ședințe live

9 luni

Intro and Course Structure

Agents Overview

- What is an AI Agent? - Examples of Agents - What are AI Agents good at? And what not?
Python Module

Python Language Basics

- Data Types and data structures - Control structures and functions - Error handling - Zen of Python

Working with Python

- Development environments (PyCharm, Colab) - Debugging - Modules and packages - Installing packages

Interactions over the network

- API interaction using requests - RESTful APIs, OpenAPI - SSH connections

File handling and logging

- Reading and writting csv and txt files - Logging: formatting strings, rotating logs - File transfers and remote file operations

Deep Learning Foundations for LLMs

Evolution of Neural Networks

- Perceptron, Multilayer Perceptron, Backpropagation - Convolutional Neural Networks and Recurrent Neural Networks - Unsupervised and Generative Models

Foundations of Transformers and Attention Mechanism

- Attention Mechanism and Self-Attention - Transformer Architecture Overview - Training Transformers - Impact and Extensions

Embedding Representations

- Word Embeddings (Word2Vec, GloVe) - Contextual Embeddings (ELMo, BERT, GPT) - Sentence and Document Embeddings (SBERT) - Efficient similarity search using cosine, dot product, or Euclidean distance - Embedding Storage and Search in Vector Databases (FAISS, Chroma)

Traditional NLP metrics

Traditional NLP metrics

- BLEU (Bilingual Evaluation Understudy) - ROUGE (Recall-Oriented Understudy for Gisting Evaluation) - METEOR (Metric for Evaluation of Translation with Explicit ORdering) - limitations of traditional metrics
Programatic Interaction with LLMs

Calling APIs via LLMs

- OpenAI API - Error Handling and Fallbacks

Tool Use with LLMs (Function Calling, Plugins, Tools API)

- Comparison of tool use vs. in-context prompting - tools vs. functions in OpenAI API - Automatic tool selection and JSON argument generation - Controlling tool order and managing tool output as new input

Context Windows, and Chunking

- Understanding the Context Window - Optimizing Context Usage - Chunking Strategies (Fixed-size chunking vs semantic chunking, Overlap windows and sliding contexts)

Multi-modal LLMs

Multi-modal Core – Vision, Audio & Video

- Image understanding & visual reasoning (charts, diagrams, screenshots) - Video understanding (frame sampling, temporal reasoning, action recognition) - Audio & speech understanding (transcription + semantic audio reasoning) - Real-time multi-modal (GPT-4o-style voice + vision) - Vision/audio Chain-of-Thought and multi-modal ReAct

Attachments & Document Handling

- Images as attachments (photos, screenshots, infographics) - OCR & layout-aware document understanding - Table extraction & reasoning over spreadsheets - Multi-page & multi-document prompts - Multi-modal structured output from documents (JSON, tables) - Tool calling with attached files

Prompting and Instruction Design

Prompt Engineering for Control and Coherence

- Structure of prompts and response shaping - Determinism vs randomness (temperature, top-p) - Instructional vs conversational prompting - Prompting for Structured Output - When to use few-shot vs zero-shot vs fine-tuning

System Messages and Role Instructions

- Designing Effective System Messages - Best Practices for Role Conditioning - Limits and Considerations

Chain-of-Thought and Reasoning Techniques

- What is Chain-of-Thought (CoT) Prompting - Zero-shot vs Few-shot CoT - Advanced Techniques (Tree-of-Thought, Self-Consistency Decoding, ReAct Prompting)

Evaluation of LLM Results

Hallucination, Bias, and Output Verification

- Hallucinations (Factual, Logical, Contextual) and mitigation strategies (prompt grounding, RAG, tool calls) - Bias and Mitigation (red-teaming, re-ranking, debias) - Verification Types (Self-Verification, Tool Assisted, Cross-Model Comparisons) and Techniques (Chain-of-Verification, Human-in-the-Loop)

Tokenization and Cost Estimation for Inference

- Monitoring and Budgeting - Prompt Optimization for Cost
Data Preparation and Representation

Document Chunking and Embedding Techniques applied on documents

Vector DBs and Semantic Search applied on documents

- Performance Considerations: pre-filtering with metadata, indexing strategy

Integration and Generation Workflow

Integrating Retrieval with LLMs - Basic RAG Architecture

- Query Embedding - Vector Search - Prompt Construction - Generation

Advanced RAG Architectures

- Hybrid RAG: dense and sparse retrieval, fusion scores - Hierarchical Retrieval: multi-stage retrieval system for large corpora - Using Knowledge Graphs

Evaluation and Optimization

Evaluation of RAG Systems

- Dimensions: Precision (Retrieval Accuracy), Relevance (Contextual Usefulness), Faithfulness (Answer Grounding) - Automatic Evaluation Tools: BERTScore, GPTScore - Human-in-the-Loop Evaluation

Advanced Topics

- Multi-Source RAG - Context Re-Ranking - Caching Strategies in RAG
Agentic AI Frameworks

Overview of LLM Agent Frameworks

- LangChain: Modular architecture: chains, tools, agents, memory - LangGraph: Graph-based orchestration using finite state machines - AutoGen: Multi-agent communication and collaboration

Designing and Building Agent Systems

Designing Task-Oriented Agents with LangChain

- Types of agents (ReAct, Zero-Shot, Plan-and-Execute) - Defining and integrating tools for task execution - Designing step-by-step workflows for real-world tasks - Prompt engineering for specific task instructions - Handling tool output and error recovery

Event-Driven Agents with LangGraph

- Differences between chain-based and event-driven design - Defining nodes and edges in LangGraph - Implementing conditional logic and branching - Event triggers and asynchronous decision-making - Designing agent workflows with feedback or loopbacks

Multi-Agent Systems Using AutoGen

- Designing multi-agent workflows and communication patterns (direct messaging, publish/subscribe, MCP) - Agent roles: coordinator, specialist, reviewer, executor - Setting up message passing between agents - Conflict resolution and consensus mechanisms - Parallel and sequential task distribution

Logging, Monitoring, and Self-Reflection

Logging, Monitoring, and Self-Reflection

- Logging agent decisions, tool usage, and intermediate steps - Monitoring performance, latency, and failure points - Agent self-reflection: asking the LLM to analyze its prior steps - Detecting drift, hallucination, or performance degradation

Enhancing Agent Behavior

Feedback Loops and Self-Correction

- Types of feedback: user feedback, system feedback, environment feedback - Implementing reflection-based re-prompting (e.g., ReAct, Reflexion) - Agent self-evaluation prompts and error checking - Strategies for enabling agents to retry or revise actions

Use A2A for feedback loops and self-correction

- Agents can ask peer agents to validate intermediate outputs. - Agents can negotiate which agent is best suited for a subtask before execution. - Conflict resolution protocols (voting, majority agreement, arbitration). - Simulate A2A communication scenarios to detect deadlocks, bottlenecks, or inconsistent outputs.

Finetuning vs Prompt Tuning for Agent Behavior

- When to use each: control, cost, data availability - Prompt tuning strategies: templates, instruction tuning, role conditioning - Tools for fine-tuning (OpenAI, Hugging Face, LoRA, PEFT) - Measuring behavioral improvement: precision, robustness, coherence - Risks: overfitting, introducing bias, loss of generalization

Enhancing Agent Memory

- Limitations given by LLM Context Windows - Memory Taxonomy in Modern AI Agents - Vector-Based Long-Term Memory - Long-term memory with Knowledge Graphs

Orchestrating and Testing Agents

Agent Orchestration vs Choreography

- Centralized vs decentralized control patterns - Orchestrator agent directing task flow - Choreographed agents reacting to events independently - Performance, scalability, and fault tolerance considerations - Task dependency management - Shared context and memory synchronization

Human-in-the-loop Design for Agentic Systems

- Human-Agent Interaction Points - Prompt-based confirmations - Custom UI workflows (form input, dropdowns, feedback buttons) - Ensuring reproducibility and accountability

Testing LLM Agents

- Adversarial Testing - Performance Testing - Safety and Ethical Testing
Deployment and Management

Deployment of Agentic Systems (Cloud, API, Docker)

- Packaging agents for deployment (Docker images, virtual environments) - Deploying agents via APIs (REST, GraphQL, FastAPI, Flask) - Hosting on cloud platforms (AWS Lambda, GCP Cloud Functions, Azure Functions) - Managing agent configurations and environment variables

Monitoring and Observability for AI Agents

- Using LangChain or OpenTelemetry for tracking agent behavior - Metrics collection (latency, token usage, success/failure rates) - Visualizing logs and behaviors (e.g., dashboards, graph flows)

MCP-aware deployment

- Deploying agents as separate services/microservices that communicate via REST, gRPC, or message queues (RabbitMQ, Kafka). - Monitoring agent-to-agent message flows, latency, and failure rates. - Test robustness of MCP protocols under network delays or partial failures.

MLOps: Managing the lifecycle of ML models in production

- Versioning of models, data, and prompts - Continuous training and evaluation pipelines - Model registry and artifact tracking (e.g., MLflow, Weights & Biases) - Serving models and agents with infrastructure (e.g., BentoML, KServe)

Safety, Security, and Ethics

Safety Constraints and Guardrails for Agentic Behavior

- Pattern matching and content filtering (e.g., regex, moderation APIs) - Rule-based vs learned safety mechanisms - Integrating human override and review points - Limiting recursion and execution steps to prevent runaway agents

Privacy, Explainability, and Ethical Considerations

- Data minimization and anonymization strategies - Avoiding leakage of sensitive data through LLM completions - Consent and transparency in human-AI interaction - Bias mitigation and fairness assessment in agent responses - Ethical review for deployment contexts (e.g., education, healthcare)

Case Studies

AI Agents in Healthcare

- Medical Literature Review Agent (RAG, LangChain, PubMed API)

AI Agents in Education

- Code Review Assistant (reviewer and explainer agents, sandbox execution)

AI Agents in eCommerce

- AI Concierge Agent (product inquiries, reroutes to human support)
Exam preparation

Exam Recap and Preparation

- Theory: Multiple-choice Examination - Practice: Final Project Presentation