What Is Agentic AI

Agentic AI is an approach where AI systems don’t just answer questions; they plan, take actions, and iterate toward a goal.

Instead of a single prompt-response, an agent can:

• Understand a task or objective
• Break it into steps
• Use tools or data sources
• Check results and adjust

This shifts AI from “chatting” to “doing,” while keeping humans in control.

Use Cases

Where agentic AI shines is in multi-step, tool-using workflows:

• Research assistants that gather, compare, and summarize sources
• Customer support bots that diagnose issues and run internal checks
• Dev copilots that run tests, read logs, and apply fixes
• Data analysis agents that query databases, build charts, and explain results
• IT / DevOps helpers that inspect systems, open tickets, and update dashboards
• Personal productivity workflows (email drafting, planning, knowledge retrieval)

Building Blocks (Overview)

Agentic AI systems typically combine these blocks:

• LLM: The reasoning and language engine
• User Interface: Where users interact and guide tasks
• Tools: Functions the AI can call (web search, code execution, APIs)
• Memory / Knowledge: Context beyond the chat (documents, databases)
• Orchestration: Logic that manages steps, retries, and safety checks

LLM Options

Commercial cloud:

• OpenAI (GPT-4/5 via API, Codex)
• Anthropic (Claude)
• Google (Gemini)

On-prem / locally hosted:

• Ollama (easy local model hosting)
• vLLM (high-throughput model serving)
• LM Studio, llama.cpp (local inference)

User Interface

Where the agent “lives” for users:

• Web UI: LibreChat, Open WebUI
• Client apps: Claude, Cursor
• CLI tools: Aider, Codex CLI

Integrated Tools (Inside the UI)

Tools allow the chatbot to act:

• Web search
• Running bash commands
• Fetching data from APIs
• Querying internal systems
• File operations and code edits

VectorDB + Embeddings (RAG) — Concepts (I)

RAG (Retrieval-Augmented Generation) adds external knowledge to a chatbot by retrieving relevant documents and feeding them into the prompt.

What is an embedding?

• A numeric vector that represents the meaning of text
• Similar meanings end up close together in a high-dimensional space
• Example: “How do I reset my password?” and “Forgot my password” are near each other
• Typical dimensions range from a few hundred to several thousand values
• Embeddings are produced by a model trained to place semantically related text nearby

VectorDB + Embeddings (RAG) — Concepts (II)

What is a VectorDB?

• Stores embeddings and supports fast similarity search
• Optimized for “find the closest vectors” rather than exact keyword match
• Examples: ChromaDB, FAISS, Weaviate
• Uses vector indexes such as HNSW, IVF, or PQ to scale to millions of items

VectorDB + Embeddings (RAG) — How It Works (I)

Similarity search in vector space

• Convert the user query into an embedding
• Compare that embedding to stored vectors using a distance metric
  • Cosine similarity (angle between vectors)
  • Euclidean distance
  • Dot product
• Return the closest matches as “retrieved context”

VectorDB + Embeddings (RAG) — How It Works (II)

Pipeline summary

1. Chunk documents
2. Embed chunks
3. Store in VectorDB
4. Embed user query
5. Retrieve top-k chunks
6. Generate answer grounded in retrieved text

MCP Servers — What and Why

MCP (Model Context Protocol) is a standard way to expose tools, data sources, and workflows to LLMs.

Why MCP matters

• Decouples tool logic from the chatbot UI
• Makes tools reusable across multiple agents and clients
• Enables consistent tool schemas and permissions

MCP Servers — JSON-RPC

JSON-RPC in a nutshell

• A lightweight protocol where a client sends a JSON request:
  • method: the function name
  • params: input arguments
  • id: request identifier
• The server returns JSON with result or error

MCP vs OpenAPI + Example

MCP server vs OpenAPI-compliant API server

• OpenAPI:
  • REST-style endpoints
  • Designed for human-written integrations
  • Strong for CRUD and public APIs
• MCP:
  • JSON-RPC methods
  • Designed for LLM tool invocation
  • Emphasizes tool discovery, schemas, and safety boundaries
• MCP tool schemas are optimized for LLM function-calling patterns
• OpenAPI focuses on HTTP resources and verbs; MCP focuses on callable tools

Minimal MCP tool definition (example)

{
  "name": "search_docs",
  "description": "Search internal docs and return top matches.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": { "type": "string" },
      "top_k": { "type": "integer", "default": 5 }
    },
    "required": ["query"]
  }
}

Agents and Agent Skills — An Example (I)

Scenario: “Run a data quality check and summarize findings.”

Agent behavior:

1. Read instructions
2. Call a tool (skill) to run a Python script
3. Parse results
4. Summarize in plain language

Agents and Agent Skills — An Example (II)

Skill: dq_check

• Implements a predefined Python script
• Allows different modes via options
• Returns structured output for the agent to interpret
• Uses exit codes to indicate success or failure

Agent Skill Design With Options (I)

Example skill interface (conceptual)

python dq_check.py  --input data.csv \
  --mode full --threshold 0.98 --report json

Options explained

• --mode quick: basic missing-value scan
• --mode full: includes schema, duplicates, and distribution checks
• --threshold 0.98: minimum acceptable completeness ratio
• --report json|md|html: output format for downstream use
• --sample: limit rows for faster checks on large files

Agent Skill Design With Options (II)

Why this matters

• The agent can select the right mode based on user intent
• Skills are reusable across projects
• Structured outputs make agent reasoning safer and more consistent
• Well-designed options reduce hallucination by constraining behavior

Closing Thought

Agentic AI is about capability + control:

• Capability comes from tools, memory, and orchestration
• Control comes from clear boundaries, permissions, and human oversight

When done well, it turns a chatbot into a reliable collaborator.