Agentic AI with Frameworks

A hands-on repository exploring Agentic AI, multi-agent systems, LLM-powered workflows, tool calling, orchestration, and the Model Context Protocol (MCP) using modern AI frameworks.

The projects in this repository are built to understand how agentic systems are designed, orchestrated, and integrated with external tools rather than treating frameworks as black boxes.

What This Repository Covers

The repository progresses from fundamental LLM and agent implementations toward more structured agentic systems.

Core Concepts

• LLM-powered agents
• Function and tool calling
• Agent planning and delegation
• Multi-agent collaboration
• Role-based agents
• Stateful workflows
• Agent orchestration
• External tool integration
• Research and automation workflows
• Structured outputs
• Agent-to-agent communication
• Model Context Protocol (MCP)

Frameworks & Technologies

| Technology | Focus | |---|---| | OpenAI | LLM APIs, tool calling, and agent fundamentals | | CrewAI | Role-based multi-agent systems | | LangGraph | Stateful graph-based agent orchestration | | AutoGen | Conversational multi-agent systems | | MCP | Model-to-tool and external system integration | | Python | Primary implementation language |

Repository Structure

Agentic_AI_with_Frameworks/
│
├── START/
│
├── Start_week2/
│
├── week3_coderTeam/
├── week3_engineeringteam/
├── week3_financial_research/
├── week3_stockpicker/
├── week3debate/
│
├── Week4_LanGraph/
├── Week5_Autogen/
└── Week6_MCP/

The projects are organized chronologically around the progression of concepts and frameworks explored.

1. Agent Fundamentals
START/

Initial experiments with LLM-powered applications and agent fundamentals.

This section focuses on understanding the basic building blocks required for agentic applications.

Concepts
Calling LLM APIs from Python
Environment-based API configuration
Agent execution
Tool/function calling
Basic agent workflows

The purpose of this section is to establish the fundamentals before moving toward multi-agent architectures.

2. Research & Multi-Agent Workflows
Start_week2/

This section explores more structured agent workflows where different agents perform specialized responsibilities.

Examples include:

Research agents
Search agents
Planner agents
Writer agents
Email agents
Deep research workflows

A representative workflow can be viewed as:

                    ┌───────────────┐
                    │    Planner    │
                    └───────┬───────┘
                            │
                            ▼
                    ┌───────────────┐
                    │ Search Agent  │
                    └───────┬───────┘
                            │
                            ▼
                    ┌───────────────┐
                    │ Research Agent│
                    └───────┬───────┘
                            │
                            ▼
                    ┌───────────────┐
                    │ Writer Agent  │
                    └───────┬───────┘
                            │
                            ▼
                         Output

The focus is on understanding how individual agents can be composed into larger workflows.

3. Multi-Agent Systems
week3_coderTeam/

A multi-agent coding workflow where specialized agents collaborate on software engineering tasks.

Concepts explored
Agent specialization
Task delegation
Multi-agent collaboration
Tool usage
Workflow coordination
week3_engineeringteam/

An engineering-oriented multi-agent system exploring how different agents can divide responsibilities within a software development workflow.

The project focuses on separating responsibilities between specialized agents rather than relying on a single general-purpose agent.

week3_financial_research/

A financial research workflow using specialized agents and external tools.

Concepts explored
Agent specialization
Research workflows
External tool integration
Task delegation
Structured execution
week3_stockpicker/

An agentic stock analysis workflow combining specialized agents with external data and tools.

The project explores how multiple agents can divide an analysis problem into specialized tasks and combine their results into a final output.

week3debate/

A multi-agent debate system where agents take different roles and produce opposing arguments before reaching a final result.

Concepts explored
Role-based agents
Agent interaction
Multi-agent communication
Parallel reasoning
Structured decision workflows

A simplified architecture:

                    ┌─────────────────┐
                    │  Topic / Input  │
                    └────────┬────────┘
                             │
                 ┌───────────┴───────────┐
                 ▼                       ▼
        ┌─────────────────┐     ┌─────────────────┐
        │  Agent: PROPOSE │     │  Agent: OPPOSE  │
        └────────┬────────┘     └────────┬────────┘
                 │                       │
                 └───────────┬───────────┘
                             ▼
                    ┌─────────────────┐
                    │ Decision / Judge│
                    └────────┬────────┘
                             │
                             ▼
                           Output
4. LangGraph
Week4_LanGraph/

Exploration of LangGraph for building stateful and controllable agent workflows.

LangGraph introduces a graph-based approach where application logic can be represented through nodes, state transitions, and conditional routing.

Concepts explored
Graph-based orchestration
State management
Agent nodes
Tool nodes
Conditional routing
Multi-step workflows
Cyclic workflows
Controlled agent execution

A simplified workflow:

          ┌──────────────┐
          │    START     │
          └──────┬───────┘
                 │
                 ▼
          ┌──────────────┐
          │    Agent     │
          └──────┬───────┘
                 │
                 ▼
          ┌──────────────┐
          │   Decision   │
          └───┬──────┬───┘
              │      │
              ▼      ▼
           Tool     Agent
              │      │
              └──┬───┘
                 │
                 ▼
            Final State

The key idea explored here is that agentic applications can be modeled as stateful computation graphs, providing greater control over execution than a simple linear chain.

5. AutoGen
Week5_Autogen/

Experiments with AutoGen and conversational multi-agent architectures.

Concepts explored
Agent-to-agent communication
Multi-agent conversations
Specialized agent roles
Human-in-the-loop workflows
Agent coordination
Automated task execution

The focus is on understanding how conversational interactions between specialized agents can be used to solve tasks collaboratively.

6. Model Context Protocol
Week6_MCP/

Exploration of the Model Context Protocol (MCP) and its approach to connecting AI models with external tools and resources.

Concepts explored
MCP clients
MCP servers
Tools
Resources
Model-to-tool communication
External system integration
Standardized tool interfaces

A simplified MCP architecture:

                  ┌──────────────┐
                  │   AI Model   │
                  └──────┬───────┘
                         │
                         ▼
                  ┌──────────────┐
                  │  MCP Client  │
                  └──────┬───────┘
                         │
                         ▼
                  ┌──────────────┐
                  │  MCP Server  │
                  └──────┬───────┘
                         │
              ┌──────────┼──────────┐
              ▼          ▼          ▼
           Tool 1      Tool 2    Resource

The objective is to understand MCP as an interoperability layer between models and external capabilities.

Architecture Patterns Explored

Across the repository, several recurring agentic architectures are implemented.

Single Agent + Tools
User
 │
 ▼
Agent
 │
 ▼
LLM
 │
 ├──── Tool Selection
 │
 ▼
External Tool
 │
 ▼
Tool Result
 │
 ▼
Agent
 │
 ▼
Response
Multi-Agent Workflow
                         ┌────────────────┐
                         │ Research Agent │
                         └───────┬────────┘
                                 │
                                 ▼
User ──► Planner ─────────► Writer Agent
                                 │
                                 ▼
                         ┌────────────────┐
                         │  Final Output  │
                         └────────────────┘

Different agents can be assigned different responsibilities instead of requiring one agent to perform the entire task.

Stateful Graph Workflow
             ┌──────────────┐
             │    START     │
             └──────┬───────┘
                    │
                    ▼
             ┌──────────────┐
             │    Agent     │
             └──────┬───────┘
                    │
                    ▼
             ┌──────────────┐
             │   Decision   │
             └───┬──────┬───┘
                 │      │
                 ▼      ▼
              Tool     Agent
                 │      │
                 └──┬───┘
                    │
                    ▼
             ┌──────────────┐
             │ Final State  │
             └──────────────┘
Engineering Principles

Working across different agentic frameworks highlighted an important distinction:

A framework is an implementation tool; it is not the architecture itself.

The same underlying agentic patterns can be implemented using different frameworks.

The important engineering questions are:

What state does the system maintain?
Which agent is responsible for each task?
When should an agent call a tool?
How is execution routed?
How are intermediate results passed between agents?
What happens when a tool fails?
How can agent behaviour be observed and debugged?
Which parts of the system should remain deterministic?
Where does an LLM actually add value?

These questions become increasingly important as systems move from simple LLM calls toward multi-agent workflows and external tool integration.

Learning Progression

The repository follows a progression from fundamental LLM interactions toward increasingly structured agentic systems:

LLM APIs
   │
   ▼
Tool Calling
   │
   ▼
Single Agents
   │
   ▼
Multi-Agent Systems
   │
   ▼
Agent Orchestration
   │
   ├──────────────► LangGraph
   │
   ├──────────────► AutoGen
   │
   ▼
External Tools & Systems
   │
   ▼
MCP

The objective is to understand not only how to use these frameworks, but also the underlying patterns that make agentic systems useful.

Running the Projects

Each project is designed to be explored independently.

Navigate into the relevant project directory and follow its project-specific README.md for setup and execution instructions.

Most projects require API credentials provided through environment variables.

For example:

OPENAI_API_KEY=your_key_here

Never commit API keys, credentials, or other secrets to the repository.

Repository Philosophy

This repository is primarily a build-and-learn repository.

The implementations are used to explore how modern agentic systems are designed and how different frameworks approach similar problems.

The progression can be summarized as:

LLMs
 ↓
Tools
 ↓
Agents
 ↓
Workflows
 ↓
Multi-Agent Systems
 ↓
Stateful Orchestration
 ↓
MCP & External Systems

The long-term objective is to move beyond framework usage toward designing and engineering reliable AI systems.

Technologies
Python
OpenAI APIs
CrewAI
LangGraph
AutoGen
MCP
REST APIs
Environment-based configuration
Jupyter Notebooks
Author
Tarkshya Bhardwaj

B.Tech — Information Technology
NIT Srinagar

Interests
LLM Engineering
Agentic AI
AI Systems
AI Security
Retrieval-Augmented Generation
Backend Engineering
---