NitiExam
Tech/AI & ML
AI & MLAdvancedv2026Updated 2026-07

AI Agents & LLMs

Building autonomous AI systems that reason and act

LLMLangChainRAGClaude APIMulti-AgentMCP

Overview

  • 1AI agents can perceive, reason, plan, and act — executing multi-step tasks with minimal human input.
  • 2Model Context Protocol (MCP, by Anthropic) standardises how LLMs connect to tools and data sources.
  • 3LangGraph enables stateful, cyclical multi-agent workflows with human-in-the-loop control.
  • 4Production AI systems in 2026 combine LLMs with vector retrieval (RAG), tools, and memory.
  • 5Claude 3.7 Sonnet, GPT-4o, and Gemini Ultra are the frontier models for agent reasoning tasks.

Key Features in 2026

Model Context Protocol (MCP) — Anthropic's open standard for LLM ↔ tool connectivity
LangGraph — stateful graph-based multi-agent orchestration with cycles and conditionals
AutoGen 0.4 — Microsoft's conversational multi-agent framework with actor model
CrewAI — role-based multi-agent teams with delegation and sequential/parallel tasks
RAG (Retrieval Augmented Generation) — ground LLM responses with private knowledge
Function/Tool Calling — structured JSON tool invocations parsed from LLM output
Evals: LangSmith, Helicone, Braintrust — trace, score, and improve agent quality

Use Cases

  • →Autonomous coding assistants that write, test, and debug code
  • →Customer support agents that look up account data and process requests
  • →Research assistants that search, read, and synthesise multi-source information
  • →Data analysis pipelines that query databases and generate reports on demand

State of AI Agents in 2026

  • Frontier models: Claude 3.7 Sonnet (top coding), GPT-4o (vision + multimodal), Gemini Ultra (long context)
  • MCP (Model Context Protocol): servers expose tools and resources; clients (Claude, Cursor) consume them
  • Agentic frameworks: LangGraph (Python/JS), AutoGen 0.4, CrewAI, Agentive, PydanticAI
  • Memory layers: in-context (conversation), external (Redis, vector store), episodic (LangMem)
  • Observability: LangSmith traces every LLM call, tool use, and token count per agent run
  • Guardrails: Constitutional AI, Llama Guard, Nemo Guardrails for output safety and policy

LangChain & LangGraph

  • LCEL (LangChain Expression Language): `chain = prompt | llm | output_parser` pipe syntax
  • LangGraph: define agents as nodes in a StateGraph; edges are conditional transitions
  • Tools: @tool decorator wraps Python functions; ToolNode runs tool calls from LLM output
  • Checkpointers: SqliteSaver, PostgresSaver — persist agent state for resume/human-in-the-loop
  • Multi-agent: supervisor node routes to specialist subgraphs; swarm pattern for parallel agents
  • LangSmith: automatic tracing of every LangChain/LangGraph invocation for debugging and evals

RAG Architecture

  • Load: document loaders (PDF, web, CSV, code) extract raw text
  • Split: RecursiveCharacterTextSplitter creates chunks with overlap for context preservation
  • Embed: text-embedding-3-small (OpenAI) or nomic-embed-text for open-source embeddings
  • Store: pgvector (PostgreSQL), Chroma (local), Pinecone/Weaviate/Qdrant (cloud vector DBs)
  • Retrieve: dense retrieval (vector search) + sparse retrieval (BM25) combined via RRF
  • Generate: retrieved chunks injected into LLM prompt as context before user question
  • Reranking: Cohere Rerank or cross-encoder models improve retrieval precision

Building with Claude API

  • Anthropic SDK: `from anthropic import Anthropic; client = Anthropic()`
  • Messages API: `client.messages.create(model="claude-opus-4-8", max_tokens=1024, messages=[...])`
  • Tool use: pass `tools=[...]` with JSON schemas; parse `tool_use` content blocks in response
  • Streaming: `with client.messages.stream(...) as stream: for text in stream.text_stream`
  • Model Context Protocol: build MCP servers that expose tools to Claude Desktop and Cursor
  • Prompt caching: `cache_control: { type: "ephemeral" }` — cache long system prompts (90% cost reduction)
  • Batch API: `client.messages.batches.create()` — async bulk processing at 50% discount

Frequently Asked Questions

What is Model Context Protocol (MCP)?

MCP is an open standard by Anthropic that defines how LLMs connect to external tools, data sources, and services. An MCP server exposes resources (data) and tools (actions) via a standard JSON-RPC interface. MCP clients (Claude Desktop, Cursor, IDE extensions) discover and call these tools. It replaces bespoke tool-use integrations with a universal connector protocol.

What is the difference between RAG and fine-tuning?

RAG retrieves relevant documents at inference time and injects them into the prompt context — no model weights change. It is best for frequently-updated private knowledge bases. Fine-tuning adjusts model weights on domain examples — best for capturing style, format, or domain-specific reasoning patterns. RAG is cheaper, more updatable, and traceable; fine-tuning is better for behavior and style changes.

How do I evaluate the quality of an AI agent?

Evaluation has three levels: unit (does a single tool call return correct output?), trajectory (does the agent take the right sequence of steps?), and end-to-end (does the final answer match the expected result?). Tools like LangSmith, Braintrust, and Ragas automate scoring with LLM-as-judge and retrieval metrics (faithfulness, answer relevance, context precision).