DOCSEARCHbyAlgolia
Submit Docs

Panaversity Learn Agentic AI

repository·main·Indexed 26 days ago

https://github.com/panaversity/learn-agentic-ai

A learning repository for the Panaversity Certified Agentic & Robotic AI Engineer program. It focuses on the Dapr Agentic Cloud Ascent (DACA) design pattern for building scalable, cloud-native AI agent systems. The documentation covers LLM selection criteria, comparisons of models like GPT, Claude, Grok, DeepSeek-R1, and Gemini Flash, implementation of dynamic instructions, and session memory management using the OpenAI Agents SDK.

Tokens
351.6K
Snippets
807
Records
1.4K
Agent score
87%

What's inside learn-agentic-ai

  1. Overview of the Learn Agentic AI Program

    main
    This repository contains learning materials for the Panaversity Certified Agentic & Robotic AI Engineer program. The curriculum focuses on the Dapr Agentic Cloud Ascent (DACA) design pattern, teaching developers how to build, scale, and deploy agentic AI systems from initial development to large-scale production environments.

  2. Overview of v0 by Vercel

    main
    v0 by Vercel is an AI-powered generative UI system that converts natural language prompts or visual inputs (images, Figma designs) into production-ready React code. It primarily uses shadcn/ui and Tailwind CSS. While originally a frontend tool, it has evolved to support full-stack Next.js application development, including multi-file projects and backend logic integration.

  3. Overview of the FastAPI, UV, and Pydantic Learning Module

    main

    This module teaches how to build a robust REST API layer for agentic AI systems using:

    • FastAPI: Modern Python web framework for async support and automatic documentation.
    • UV: Fast Python dependency management.
    • Pydantic: Data validation and serialization.

    Learning Path:

    1. Setup & Hello FastAPI: Project initialization with uv and basic endpoints.
    2. Pydantic Validation: Defining request/response structures.
    3. API Parameters: Using path, query, and request body parameters.
    4. Dependency Injection: Managing reusable logic and dependencies.
    5. API Testing with Pytest: Writing unit and integration tests.
    6. OpenAI Agents SDK with FastAPI: Integrating autonomous agents into FastAPI endpoints.

  4. Overview of OpenAI Agents SDK

    main
    The OpenAI Agents SDK is an open-source, lightweight Python framework designed for building and orchestrating 'agentic' AI applications. It allows developers to create systems where multiple AI agents work together autonomously to perform complex, multi-step tasks. The SDK is designed to be interoperable with any model provider that supports the Chat Completions API format, though it is optimized for OpenAI models and the Responses API.

  5. Overview of Graphiti: Temporal Knowledge Graphs Engine

    main

    Graphiti is a temporal knowledge graph framework used to power memory architectures for AI agents. It allows developers to transform unstructured text, conversations, or data into structured knowledge graphs.

    Key capabilities include:

    • Knowledge Graph Construction: Building graphs from text, messages, or JSON.
    • Semantic Retrieval: Searching and retrieving information using semantic queries.
    • Domain Modeling: Creating custom entity types and relationships.
    • Temporal Memory: Managing information that evolves over time.
    • MCP Integration: Deploying memory systems via Model Context Protocol (MCP).

  6. Overview of Caitlyn - Optimization Agent (LangGraph)

    main

    Caitlyn is an intelligent scheduling optimization specialist built using the LangGraph framework. It is designed for complex decision-making, specifically focusing on multi-objective optimization and constraint satisfaction. The agent is intended to integrate with the A2A protocol for sophisticated multi-agent coordination.

    Core Capabilities

    • Multi-objective scheduling optimization: Using optimize_scheduling to balance competing goals.
    • Constraint satisfaction: Solving complex problems via solve_constraints.
    • Outcome prediction: Using machine learning-based schedule prediction via predict_outcomes.
    • Resource management: Optimizing allocation and utilization via balance_resources.
    • Conflict resolution: Minimizing conflicts through intelligent rescheduling via minimize_conflicts.
    • Stakeholder satisfaction: Maximizing preference optimization via maximize_satisfaction.

  7. Manage Dapr Workflow Lifecycles

    main

    Once workflows are authored and running, you can manage their lifecycle using the Dapr Workflow Management API, which is accessible via Dapr client SDKs or the HTTP API. The available management operations include:

    1. Start a Workflow: Scheduling a new workflow instance.
    2. Get Status: Querying the current status and metadata of a workflow.
    3. Pause: Suspending a running workflow.
    4. Resume: Continuing a paused workflow.
    5. Terminate/Cancel: Stopping a workflow instance.
    6. Raise External Event: Triggering an external event to interact with a running workflow.

  8. Understand the advantages of the Actor Model in DACA

    main

    The Actor Model, implemented via Dapr Actors, provides several key benefits for building agentic AI systems within the DACA (Dapr Agentic Cloud Ascent) design pattern:

    • Simplicity: Dapr Actors abstract concurrency and state management. Execution is single-threaded per actor, which simplifies debugging of AI logic (using OpenAI Agents SDK, MCP, or A2A).
    • Scalability: Actors scale horizontally across Kubernetes or Azure Container Apps (ACA). Dapr handles placement and load balancing.
    • Fault Tolerance: Failures are isolated within individual actors. Resilience is enhanced through Dapr's retries, HITL (Human-in-the-loop) workflows, and supervisor actors that manage child actor lifecycles.
    • Asynchronous/Event-Driven: Actors align with Event-Driven Architecture (EDA), processing events from Kafka or A2A asynchronously.
    • Interoperability: Dapr Actors integrate with A2A's Agent Cards and MCP's tool-calling for cross-platform dialogues.

  9. Architecture of the Event Planner Agent System

    main

    The Event Planner Agent is designed as a multi-agent system using LLM-based orchestration. It operates as an independent service/container that communicates with other agents and external services.

    Key Components

    • Front-End Orchestration Agent: Centralized interface for conversation and task delegation. Routes event-related requests to the Event Planner Agent.
    • Event Planner Agent: The core service that interprets user queries, calls tools (via LLM function-calling), and proposes plans.
    • Greeting Agent: Handles small talk.
    • User Preference Agent: Stores organizer preferences like budget, dietary restrictions, and location styles.
    • Knowledge Graph Agent (Optional): Stores relationships between vendors, venues, and themes.
    • Mail Processing Agent (Optional): Automates invitations and confirmations.

    Communication & Patterns

    • Protocols: Use HTTP, gRPC, or message queues for inter-agent communication.
    • Human-in-the-Loop: The system must require explicit user confirmation (approve, reject, or modify) for major or costly decisions like booking confirmations or vendor contracts.

  10. Understand the Assistant Selector Router Pattern

    main

    The Assistant Selector implements the Router Pattern in LangGraph to optimize response quality by directing user queries to specialized agents.

    Workflow Components:

    1. Question Classifier: Analyzes the input and categorizes it as a Simple question, Complex question, or Code-related question.
    2. Router: Uses the classification to select the appropriate specialized assistant.
    3. Specialized Assistants:
      • Simple Assistant: Optimized for quick, factual responses.
      • Complex Assistant: Optimized for detailed, in-depth explanations.
      • Code Assistant: Optimized for code analysis, implementation, and debugging.
    4. Aggregator: Collects the output from the selected assistant to provide the final response.

  11. Understand the Agent Executor Pattern

    main

    The Agent Executor acts as a translation layer between the A2A Protocol (JSON-RPC/HTTP) and your agent's Business Logic (pure Python). This three-layer architecture ensures that complex protocol requirements are handled separately from your core agent functionality.

    Architecture Layers:

    1. A2A Protocol: Manages JSON-RPC 2.0, HTTP transport, and the .well-known/agent-card.json endpoint.
    2. Agent Executor: Translates A2A requests into agent methods, routes requests based on skills, and manages RequestContext and EventQueue flows.
    3. Business Logic: Pure Python methods (e.g., calendar, data processing) that are independent of the A2A protocol.

  12. Configure containers using Kubernetes ConfigMaps

    main

    Kubernetes ConfigMaps store non-sensitive configuration data (key-value pairs or files) to decouple application settings from container images. This allows you to reuse the same image across different environments (dev, test, prod) by injecting different configurations at runtime.

    Supported Injection Methods:

    • Inside a container command and arguments.
    • As environment variables for a container.
    • As files in a read-only volume for the application to read.
    • Using the Kubernetes API directly from within the application code.

    ⚠️ Security Warning: Do not use ConfigMaps to store sensitive data like GEMINI_API_KEY. ConfigMaps do not provide encryption or protection for their contents. Use a secrets management solution for sensitive data.