Core idea: Agent అనేది చాలా complicated magic system కాదు. ఒక Model situation ని అర్థం చేసుకుని decision తీసుకుంటుంది; Tools ఆ decision ని real action గా మార్చుతాయి. Simple గా: Brain + Hands = Agent.

1. Model మాత్రమే ఉంటే ఏమి చేయగలదు?

Model ఒక smart advisor లాంటిది. మన request అర్థం చేసుకోవచ్చు, reasoning చేయవచ్చు, answer లేదా plan generate చేయవచ్చు. కానీ external system access లేకపోతే అది mostly text response వరకే limited.

ఉదాహరణకు, “నా project tasks లో overdue items find చేసి owners కి reminder పంపు” అని అడిగితే model:

• task ని అర్థం చేసుకుంటుంది,
• ఎలాంటి steps కావాలో plan చేస్తుంది,
• reminder message draft చేయగలదు.

కానీ database read చేసే tool, current date తెలుసుకునే access, message పంపే tool లేకపోతే actual overdue tasks find చేయలేదు, reminders send చేయలేదు. అంటే intelligence ఉంది; execution ability లేదు.

2. Tools ఎందుకు అవసరమయ్యాయి?

Traditional program లో developer ముందే exact flow రాస్తారు:

Step 1 → Step 2 → Step 3

కానీ real-world user requests fixed format లో రావు. ఒకరు “urgent emails చూపించు” అంటారు; ఇంకొకరు “ఈరోజు respond చేయాల్సిన mails ఏవి?” అంటారు. Meaning similar అయినా wording different.

LLM flexible language ని అర్థం చేసుకోగలదు. Tools reliable actions చేయగలవు. ఈ రెండింటిని combine చేస్తే:

• Model ఏ పని చేయాలో decide చేస్తుంది.
• Tool ఆ పని ఎలా execute చేయాలో predefined code ద్వారా చేస్తుంది.
• Application permissions, validation, logging ని control చేస్తుంది.

ఇందుకే agent concept develop అయింది: natural-language intelligence ని existing software capabilities తో connect చేయడానికి.

3. Python function ఎలా tool అవుతుంది?

Python function సాధారణంగా clear input తీసుకుని specific output ఇస్తుంది:

def get_overdue_tasks(project_id, current_date):
    # Database/API నుంచి overdue tasks fetch చేస్తుంది
    return overdue_tasks

ఈ function ని agent కి tool గా expose చేసేటప్పుడు model కి ఒక description మరియు input schema ఇస్తాం:

• Tool పేరు: get_overdue_tasks
• Purpose: project లో incomplete, overdue tasks fetch చేయడం
• Inputs: project_id, current_date
• Output: task title, owner, due date వంటి structured data

User request వచ్చినప్పుడు model function code ని rewrite చేయదు. Available tools list చూసి correct tool select చేసి required arguments తయారు చేస్తుంది. Application arguments validate చేసి function execute చేస్తుంది. Result model కి తిరిగి వస్తుంది.

💡 Model tool ని select చేస్తుంది; actual application/tool ఆ action ని execute చేస్తుంది. ఈ separation reliability మరియు security కి చాలా important.

4. ఒక function ఇంకో function ని call చేయడం అంటే?

Transcript లో “one Python function can call another Python function” అన్నారు. ఇది normal programming లో function composition. Agent workflows లో ఇదే idea multi-step orchestration గా కనిపిస్తుంది.

ఉదాహరణకు handle_overdue_tasks() అనే workflow లో:

1. get_overdue_tasks() — overdue tasks fetch చేస్తుంది.
2. get_task_owner() — ప్రతి task owner details తెస్తుంది.
3. draft_reminder() — context ఆధారంగా message తయారు చేస్తుంది.
4. request_approval() — send చేయడానికి ముందు human confirmation తీసుకుంటుంది.
5. send_message() — approved message పంపుతుంది.
6. update_task_log() — reminder sent అని record చేస్తుంది.

ఇక్కడ రెండు implementation styles ఉండవచ్చు:

• Fixed workflow: developer functions ని predetermined order లో chain చేస్తారు. Predictable tasks కి ఇది safe.
• Dynamic agent loop: ప్రతి result చూసి model next tool ఏది అని decide చేస్తుంది. Flexible tasks కి useful, కానీ stronger guardrails అవసరం.

5. Agent reasoning loop ఎలా పనిచేస్తుంది?

ఒక basic agent flow ఇలా ఉంటుంది:

User Goal
→ Intent అర్థం చేసుకోవడం
→ Plan తయారు చేయడం
→ Correct Tool select చేయడం
→ Inputs validate చేయడం
→ Tool execute చేయడం
→ Result observe చేయడం
→ Goal complete అయిందా verify చేయడం
→ Next tool / clarification / approval / final response

ఈ cycle ని Observe → Reason → Act → Verify అని గుర్తుంచుకోవచ్చు.

ఉదాహరణకు weather ఆధారంగా meeting reschedule చేసే agent:

1. Calendar tool తో event details చదువుతుంది.
2. Weather tool తో forecast check చేస్తుంది.
3. Participants availability compare చేస్తుంది.
4. Better slots suggest చేస్తుంది.
5. User approval తర్వాత మాత్రమే calendar update చేస్తుంది.

Reasoning అవసరమయ్యే point ఏమిటంటే: rain chance ఉందని meeting వెంటనే cancel చేయడం సరైన decision కాదు. Meeting indoorనా, outdoorనా? Attendees availability ఏంటి? Rescheduling cost ఎంత? Context evaluate చేయాలి.

6. ఎక్కడ agents నిజంగా useful?

Repetitive multi-step work

• Invoice చదవడం → amount validate చేయడం → accounting entry draft చేయడం
• Support ticket analyse చేయడం → category assign చేయడం → knowledge-base answer draft చేయడం
• Meeting transcript summarize చేయడం → decisions extract చేయడం → tasks create చేయడం

Information scattered across systems

• CRM, email, calendar data combine చేసి customer follow-up prepare చేయడం
• Logs, monitoring alerts, recent deployments compare చేసి incident cause investigate చేయడం
• Multiple travel sites నుంచి price, duration, baggage details compare చేయడం

Context ఆధారంగా decision మారే work

• ప్రతి customer కి same response కాకుండా history ఆధారంగా reply personalize చేయడం
• Task priority ని due date, blocker, business impact ఆధారంగా నిర్ణయించడం
• Candidate profile ని job requirements తో compare చేసి review notes తయారు చేయడం

Single, deterministic action కోసం agent అవసరం లేకపోవచ్చు. Simple function చాలొచ్చు. Ambiguous, multi-step, context-dependent workflow ఉన్నప్పుడు agent ఎక్కువ value ఇస్తుంది.

7. Reliable agent ఎలా build చేస్తారు?

1. Goal define చేయాలి: agent success అంటే ఏమిటో measurable గా చెప్పాలి.
2. Tool boundaries పెట్టాలి: ప్రతి tool ఒక clear పని మాత్రమే చేయాలి.
3. Structured inputs use చేయాలి: free-text ని directly dangerous actions కి pass చేయకూడదు.
4. Least privilege ఇవ్వాలి: read అవసరమైతే write access ఇవ్వకూడదు.
5. Human approval gates పెట్టాలి: payment, deletion, external message, production deployment ముందు confirmation అవసరం.
6. Results verify చేయాలి: tool call success అయిందా, returned data completeనా check చేయాలి.
7. Error handling పెట్టాలి: API fail అయితే retry, alternate path లేదా clear escalation ఉండాలి.
8. Logs maintain చేయాలి: agent ఏ tool ఎందుకు call చేసింది, result ఏమిటి అనే audit trail ఉండాలి.
9. Test scenarios తయారు చేయాలి: happy path తో పాటు missing data, conflicting instructions, duplicate actions, malicious input కూడా test చేయాలి.

8. “Agent” term ని over-hype చేయకూడదు అంటే?

ప్రతి automation ని intelligent agent అని పిలవడం వల్ల concept confusing అవుతుంది. Practical difference ఇలా చూడొచ్చు:

• Function: ఒక specific action.
• Workflow: predefined sequence of actions.
• Copilot: human తో కలిసి suggestions లేదా drafts ఇస్తుంది.
• Agent: goal ఆధారంగా next action/tool decide చేసి కొంత autonomy తో workflow నడుపుతుంది.

ఎక్కువ autonomy ఎప్పుడూ better కాదు. Predictable payroll calculation కోసం fixed workflow agent కంటే safer కావచ్చు. Open-ended research లేదా support triage కోసం agent flexibility useful కావచ్చు. Correct solution task risk మరియు variability ఆధారంగా choose చేయాలి.

9. ఒక complete example — Meeting Notes Agent

ఈ page context నే example గా తీసుకుంటే, Meeting Notes Agent కి tools ఇలా ఉండవచ్చు:

• load_transcript() — transcript చదవడం
• extract_topics() — main concepts identify చేయడం
• find_decisions() — decisions detect చేయడం
• extract_action_items() — task, owner, due date identify చేయడం
• create_tasks() — approved tasks ని database లో create చేయడం
• draft_follow_up() — participants కి follow-up message తయారు చేయడం
• update_notes_page() — explanation ని meeting block కింద add చేయడం

Model transcript context బట్టి ఏ tools అవసరమో decide చేస్తుంది. కానీ action item owner లేదా due date transcript లో లేకపోతే guess చేయకుండా “owner not specified” అని mark చేయాలి లేదా clarification అడగాలి.

✅ Final takeaway: Agent = Model + Tools అని చెప్పడం foundation. Production-ready agent కావాలంటే context, planning, permissions, approvals, validation, memory, error handling, verification కూడా అవసరం. Building agents hands-on గా practice చేస్తేనే tool selection, chaining, failures మరియు safety trade-offs clear గా అర్థమవుతాయి.

🧠 Simple formula: LLM / Model = Brain; Tools + APIs = Hands & Legs; Memory + Planning + Guardrails కలిస్తే = Useful AI Agent.

1. అసలు Agentic AI అంటే ఏమిటి?

Normal chatbot కి మనం question అడిగితే అది answer ఇస్తుంది. కానీ Agentic AI కేవలం answer ఇవ్వడం దగ్గర ఆగదు. మన goal ని అర్థం చేసుకుని, దాన్ని చిన్న steps గా break చేసి, అవసరమైన tools ని select చేసి, actions perform చేసి, result ని verify చేయడానికి ప్రయత్నిస్తుంది.

ఉదాహరణకు, “రేపు Mumbai కి cheapest flight చూసి చెప్పు” అంటే:

1. Travel date, source city వంటి missing details గుర్తిస్తుంది.
2. Flight search tool లేదా travel API ని call చేస్తుంది.
3. Price, duration, stops, baggage rules compare చేస్తుంది.
4. Best options ని reason చేసి shortlist చేస్తుంది.
5. Booking ముందు payment వంటి sensitive action కి మన approval అడుగుతుంది.

అంటే chatbot “ఏం చేయాలో చెబుతుంది”; agent అయితే, permission ఉన్నంతవరకు, “ఆ పని చేయడానికి steps తీసుకుంటుంది.”

2. ఈ concept ఎందుకు develop చేయాల్సి వచ్చింది?

Traditional software mostly UI-driven. ప్రతి task కోసం app open చేయాలి, menus navigate చేయాలి, data copy-paste చేయాలి, repeated clicks చేయాలి. చిన్న పని అయినా మనమే మొత్తం workflow నడపాలి.

LLMs వచ్చాక natural language లో intent చెప్పడం easy అయింది. కానీ model ఒక్కటే ఉంటే అది text generate చేస్తుంది; real-world systems లో action చేయలేదు. ఉదాహరణకు email draft చేయగలదు, కానీ email tool లేకపోతే send చేయలేదు. Calendar plan చెప్పగలదు, కానీ Calendar API లేకపోతే event create చేయలేదు.

అందుకే next logical step: model reasoning + software tools + controlled access. దీని వల్ల మనం exact buttons ఎలా click చేయాలో చెప్పకుండా desired outcome చెప్పగలం.

Traditional software: “ఈ button click చెయ్యి, తర్వాత ఆ form fill చెయ్యి.”

Agentic software: “ఈ outcome కావాలి; constraints ఇవి; safe గా complete చెయ్యి.”

3. AI evolution ని simple గా అర్థం చేసుకుందాం

• Before generative AI: ఎక్కువ AI systems narrow task కోసం ఉండేవి — spam detection, recommendations, fraud scoring లాంటివి.
• Chatbot phase: ChatGPT తర్వాత general questions, emails, summaries, coding help వంటి tasks popular అయ్యాయి.
• Copilot phase: AI మనతో కలిసి పని చేస్తుంది, కానీ ప్రతి major step మనమే initiate చేస్తాం.
• Agent phase: మనం goal ఇస్తాం; AI plan చేసి, tools use చేసి, multi-step workflow execute చేస్తుంది.

ఇది sudden magic change కాదు. అదే models కి tools, memory, planning loop, permissions, monitoring add చేయడం వల్ల autonomy పెరుగుతుంది.

4. Brain–Body analogy

• LLM = Brain: language అర్థం చేసుకోవడం, reasoning చేయడం, plan తయారు చేయడం.
• Vision = Eyes: images/video చూసి objects లేదా issues detect చేయడం.
• Speech/Audio = Ears: voice లేదా audio అర్థం చేసుకోవడం.
• OCR = Reading ability: scanned document, invoice, image లో text extract చేయడం.
• Tools / Functions = Hands & Legs: email send చేయడం, database update చేయడం, ticket create చేయడం, search చేయడం.
• Memory = Notebook: previous context, preferences, earlier outcomes గుర్తుంచుకోవడం.
• Guardrails = Rules & Brakes: agent ఏం చేయవచ్చు, ఏం చేయకూడదు, ఎక్కడ approval కావాలి అని control చేయడం.

Brain powerful గా ఉన్నా hands లేకపోతే పని చేయలేదు. అదే విధంగా tools ఉన్నా brain సరిగ్గా reason చేయకపోతే wrong tool లేదా wrong parameters use చేసే risk ఉంటుంది. రెండూ కలిసినప్పుడే useful agent వస్తుంది.

5. Python function ఎలా AI tool అవుతుంది?

Normal Python function కి clear inputs, action, output ఉంటాయి. ఉదాహరణకు:

def search_flights(source, destination, travel_date):
    # Travel API ని call చేసి options return చేస్తుంది
    return flight_options

ఈ function గురించి model కి మూడు విషయాలు చెబుతాం:

1. Tool పేరు ఏమిటి?
2. Tool ఏ పని చేస్తుంది?
3. Required inputs మరియు expected output ఏమిటి?

User request వచ్చినప్పుడు model direct గా arbitrary code run చేయకుండా, structured arguments తో allowed tool ని request చేస్తుంది. Application ఆ arguments validate చేసి function/API execute చేస్తుంది. Result తిరిగి model కి వస్తుంది; model దాన్ని analyse చేసి next step నిర్ణయిస్తుంది.

User Goal → Model Understands Intent → Creates Plan → Selects Tool
→ Application Validates Permission → Tool Executes → Result Returns
→ Model Checks Result → Next Tool / Final Answer / Human Approval

ఈ repeated cycle ని చాలాసార్లు agent loop అంటారు: Observe → Think/Plan → Act → Check.

6. Flight-booking example లో reasoning ఎలా జరుగుతుంది?

“I want to fly to Mumbai tomorrow; cheapest practical option కావాలి” అనుకుందాం. Agent blind గా cheapest ticket book చేయకూడదు. “Cheapest” కి hidden constraints ఉంటాయి:

• Departure city ఏమిటి?
• Direct flight కావాలా, layover okayనా?
• Baggage అవసరమా?
• Departure time flexibleనా?
• Refundable ticket కావాలా?
• Airport transfer cost కలిపితే నిజంగా ఏది cheap?

Good agent ఈ ambiguity ని recognise చేస్తుంది. Missing critical information అడుగుతుంది; available preferences/memory ఉన్నప్పుడు వాటిని use చేస్తుంది. Options compare చేసి recommendation ఇవ్వగలదు. కానీ final purchase, payment, cancellation వంటి high-impact action ముందు confirmation తీసుకోవడం safest design.

7. Practical use cases

Personal productivity

• Inbox read చేసి priority emails summarize చేయడం
• Reply draft తయారు చేసి approval తర్వాత send చేయడం
• Calendar conflicts చూసి meeting slots suggest చేయడం
• Travel plan, bookings, reminders coordinate చేయడం

Software engineering

• Requirement చదివి subtasks create చేయడం
• Repository search చేసి affected files identify చేయడం
• Code change propose చేసి tests run చేయడం
• Failure logs analyse చేసి likely root cause explain చేయడం

Business operations

• New customer onboarding steps coordinate చేయడం
• CRM record update చేసి follow-up task create చేయడం
• Invoice నుంచి OCR ద్వారా data తీసి validation చేయడం
• Support ticket classify చేసి correct team కి route చేయడం

Safety and monitoring

Transcript లోని construction-site example తీసుకుంటే, camera footage ని Vision model analyse చేసి helmet లేకుండా ఉన్న worker ని detect చేయవచ్చు. కానీ ideal system వెంటనే punishment action తీసుకోకుండా site manager కి alert, timestamp, image evidence పంపాలి. Human verify చేసిన తర్వాత action తీసుకోవాలి. Poor lighting, camera angle, occlusion వల్ల false positive రావచ్చు.

8. Cloud, open-source, local models — ఏది ఎప్పుడు?

• Cloud-hosted model: setup easy, strong capability, scalable. కానీ usage cost, internet dependency, data/privacy policies చూడాలి.
• Open-source model: customization మరియు control ఎక్కువ. కానీ hosting, updates, security, performance tuning మన responsibility.
• Local model: sensitive data device/network బయటకు వెళ్లకూడని cases కి useful. కానీ hardware limits వల్ల speed లేదా quality compromise కావచ్చు.

“Latest model ఏది?” కంటే task కి correct model ఏది? అన్నది ముఖ్యమైన question. Model versions వేగంగా మారుతాయి; transcript లో చెప్పిన version numbers ని time-sensitive examples గా మాత్రమే చూడాలి.

9. Agent build చేయడానికి practical architecture

1. Goal & Instructions: responsibility, boundaries, success criteria clear గా define చేయాలి.
2. Model: reasoning quality, cost, latency ఆధారంగా select చేయాలి.
3. Tools: small, well-defined functions/APIs ఇవ్వాలి; unnecessary broad access avoid చేయాలి.
4. Context / Retrieval: relevant documents, policies, database records మాత్రమే fetch చేయాలి.
5. Memory: useful preferences store చేయాలి; sensitive data కి retention rules పెట్టాలి.
6. Planner / Execution loop: plan, tool call, observation, verification cycle implement చేయాలి.
7. Permissions & Approvals: read, write, payment వంటి actions కి different controls ఉండాలి.
8. Testing & Monitoring: ambiguous requests, tool failures, wrong data, prompt injection వంటి edge cases test చేయాలి.

10. Important limitations and safety

Agent confident గా మాట్లాడిందంటే answer correct అని guarantee లేదు. Models hallucinate చేయవచ్చు; tools fail కావచ్చు; APIs stale data ఇవ్వవచ్చు; user intent ambiguous ఉండవచ్చు.

• Financial, legal, medical, deletion, payment వంటి high-impact actions కి human approval పెట్టాలి.
• Least-privilege principle follow చేయాలి — అవసరమైన access మాత్రమే ఇవ్వాలి.
• Tool inputs validate చేయాలి; raw model output ని blindly execute చేయకూడదు.
• Important facts ని trusted source తో verify చేయాలి.
• Logs, audit trail, rollback option maintain చేయాలి.
• Agent తన పని complete అయిందని చెప్పే ముందు actual tool result check చేయాలి.

✅ Final takeaway: Agentic AI అంటే కొత్తరకం “magic AI” కాదు. Powerful language model కి carefully designed tools, data access, memory, planning, verification, permissions కలిపి real-world goal complete చేయించే software approach. Autonomy ఎంత పెరుగుతుందో, safety controls కూడా అంత strong గా ఉండాలి.

1. AI application vs AI model — difference ఏంటి?

సింపుల్‌గా చెప్పాలి అంటే, Gemini/ChatGPT లాంటి products are AI applications. వాటి లోపల ఒకటి లేదా ఎక్కువ AI models ఉంటాయి. Model answer generate చేయగలదు, కానీ complete application అవ్వడానికి UI, backend, login, payment, database, monitoring, rate limits, security, user history, file uploads, APIs — ఇవన్నీ కావాలి.

Model ని “brain” అనుకుంటే, application అనేది “brain + body + workflow + rules”. Brain ఒక్కటే ఉంటే user కి usable product రాదు.

ఎందుకు ఈ separation వచ్చింది?
Early software mostly rule-based. Developer every behavior code లో రాస్తారు. కానీ natural language questions కి fixed rules సరిపోవు. అందుకే AI model ని application లో ఒక intelligent component లాగా integrate చేయడం మొదలైంది.

ఎలా build చేస్తారు?

1. Frontend user question తీసుకుంటుంది
2. Backend ఆ request ని receive చేస్తుంది
3. అవసరమైతే database/tools/RAG నుంచి context తెస్తుంది
4. AI model కి prompt పంపుతుంది
5. Model response ఇస్తుంది
6. Application response ని format చేసి user కి చూపిస్తుంది

Use case:
Telusko chatbot లో user “AI course ఏది start చేయాలి?” అని అడిగితే, application user question తీసుకుని, Telusko course data fetch చేసి, model ద్వారా natural answer generate చేయాలి. Model alone random answer ఇవ్వచ్చు; application logic దాన్ని controlled answer గా మార్చుతుంది.

Real-world point:
Production AI app లో model quality మాత్రమే కాదు — latency, cost, privacy, fallback, logging, evaluation ఇవన్నీ equally important.

2. LLM prediction చేస్తుంది, database lookup కాదు

LLM అంటే Large Language Model. ఇది normal database లాగా exact row fetch చేయదు. ఇది text patterns నేర్చుకుని next token prediction చేస్తుంది. మన keyboard suggestions చిన్న scale లో ఎలా work అవుతాయో, LLM huge scale లో అలాగే but much more advanced గా work చేస్తుంది.

ఎందుకు develop చేయాల్సి వచ్చింది?
Human language చాలా flexible. “Python explain చేయి”, “Python అంటే ఏంటి?”, “Python beginner కి ఎలా చెప్తావు?” — meaning దగ్గరగా ఉన్నా wording different. ప్రతి possible wording కి code రాయడం impossible. అందుకే model ని huge examples మీద train చేసి language patterns నేర్పిస్తారు.

ఎలా చేస్తారు?

1. Huge text corpus collect చేస్తారు
2. Text ని tokens గా split చేస్తారు
3. Model కి “given previous tokens, next token ఏమై ఉండొచ్చు?” అనే task మీద train చేస్తారు
4. Training లో billions/trillions parameters adjust అవుతాయి
5. Inference time లో user prompt చూసి next tokens generate చేస్తుంది

Important reasoning:
Model “understanding” అనేది human understanding లాంటిదా కాదా అనేది philosophical debate. Practical engineering view లో మాత్రం model patterns capture చేసి useful outputs ఇస్తుంది.

Use case:
User “resume summary improve చేయి” అంటే model grammar, tone, professional wording patterns use చేసి better summary generate చేస్తుంది.

3. Hallucination — confident గా wrong answer ఇవ్వడం

Hallucination అంటే AI confident గా wrong/fake answer ఇవ్వడం. ఇది “model bad” అని మాత్రమే కాదు; model design nature వల్ల వచ్చే limitation. Model truth verify చేయకుండా likely text generate చేస్తుంది.

ఎందుకు జరుగుతుంది?

• Prompt లో enough context లేకపోవడం
• Model training data లో fact లేకపోవడం
• User question ambiguous గా ఉండడం
• Model కి “answer తప్పనిసరిగా ఇవ్వాలి” అన్న pressure ఉండడం
• External verification లేకపోవడం

ఎందుకు dangerous?

• Medical/legal/finance domains లో wrong answer big risk
• Company policy chatbot wrong policy చెప్పొచ్చు
• Developer కి fake library/function suggest చేయొచ్చు
• Student కి wrong concept confidently నేర్పొచ్చు

ఎలా handle చేస్తారు?

• RAG: trusted documents నుంచి context ఇచ్చి answer చేయించడం
• Tool calling: live API/database నుంచి facts తెప్పించడం
• Prompt constraints: “Context లో లేకపోతే తెలియదు అని చెప్పు”
• Citations: answer ఏ document మీద based ఉందో చూపించడం
• Human review: high-risk outputs manual review చేయించడం
• Validation: output schema, business rules, factual checks apply చేయడం

Use case:
Company HR bot “paid leave policy” గురించి answer ఇవ్వాలి. Base LLM మీద depend అయితే hallucination risk. HR policy PDF నుంచి RAG context retrieve చేసి answer చేస్తే grounded response వస్తుంది.

4. Knowledge cutoff and tool calling

Model ఒక time వరకు train అవుతుంది. ఆ తర్వాత జరిగిన events model memory లో ఉండవు. దీనినే knowledge cutoff అంటారు. కానీ tools ఉంటే model live information తీసుకోగలదు.

Tool calling అంటే ఏంటి?
LLM కి outside systems ని call చేసే ability ఇవ్వడం. Model “నాకు current date కావాలి”, “calendar check చేయాలి”, “database query చేయాలి”, “calculator use చేయాలి” అని decide చేసి tool call చేస్తుంది.

ఎందుకు develop చేయాల్సి వచ్చింది?

• World data changes every second
• Model retrain చేయడం costly and slow
• Company private data model training లో ఉండదు
• Some tasks require action, not just answer

ఎలా works?

1. User request వస్తుంది
2. Model intent అర్థం చేసుకుంటుంది
3. Available tools list చూస్తుంది
4. సరైన tool choose చేస్తుంది
5. Tool కి structured input ఇస్తుంది
6. Tool result తిరిగి model కి వస్తుంది
7. Model final answer/action చేస్తుంది

Use cases:

• “నా next meeting ఎప్పుడు?” → Calendar tool
• “ఈ order status ఏంటి?” → Database/API tool
• “ఈ calculation correct ఆ?” → Calculator tool
• “GitHub లో issue create చేయి” → GitHub tool

Important point:
Tool calling వల్ల model “knowledge source” కాకుండా “reasoning + orchestration layer” అవుతుంది.

5. Tokens, token IDs, vectors/embeddings — language ని numbers గా మార్చడం

LLM text ని direct గా process చేయదు. Text first tokens గా split అవుతుంది. Token word కావచ్చు, word part కావచ్చు, punctuation కూడా కావచ్చు.

Example:

• “unbelievable” ఒక token కావచ్చు లేదా “un”, “believ”, “able” లా multiple tokens కావచ్చు
• “Explain Java collections” multiple tokens అవుతుంది

Flow:

1. Text → tokens
2. Tokens → token IDs
3. Token IDs → embeddings/vectors
4. Vectors → Transformer layers
5. Output tokens → final text

Embedding అంటే ఏంటి?
Embedding అంటే word/sentence meaning ని numbers list గా represent చేయడం. Similar meaning ఉన్న words vectors space లో దగ్గరగా ఉంటాయి.

Example:

• “car” and “automobile” meanings similar, vectors close
• “king” and “queen” relation meaningful గా capture అవుతుంది
• “bank” meaning context బట్టి river/finance వైపు shift అవుతుంది

ఎందుకు develop చేయాల్సి వచ్చింది?
Computers numbers మీద operate చేస్తాయి. Language meaning ని mathematical form లోకి convert చేస్తే machine similarity, context, relationship analyze చేయగలదు.

Use case:
Search system లో user exact keyword use చేయకపోయినా similar meaning documents retrieve చేయగలము. ఇది RAG కి base.

6. Transformer architecture — modern LLMs కి core engine

Transformer architecture 2017 “Attention is All You Need” paper వల్ల popular అయింది. ChatGPT, Gemini, Claude లాంటి systems Transformer family మీద based.

Old problem ఏంటి?
Older sequence models long context handle చేయడం లో weak. Sentence లో earlier word later meaning ని affect చేస్తే capture చేయడం difficult.

Example:

“The trophy doesn’t fit in the suitcase because it is too small.”
ఇక్కడ “it” suitcase ని refer చేస్తుంది. Context understand చేయాలి.

Attention mechanism అంటే?
Model ప్రతి token processing సమయంలో, sentence లోని other tokens లో ఏవి important అనేది weight చేస్తుంది. దీనివల్ల context relationships capture అవుతాయి.

ఎలా high level లో work చేస్తుంది?

1. Tokens embeddings గా convert అవుతాయి
2. Positional information add చేస్తారు — word order తెలియాలి కాబట్టి
3. Attention layers relevant tokens మీద focus చేస్తాయి
4. Feed-forward layers meaning refine చేస్తాయి
5. Multiple layers repeat అవుతాయి
6. Final layer next token probabilities ఇస్తుంది

Use case:
Long prompt లో “answer Telugu-English mix లో ఇవ్వు” అని beginning లో చెప్పినా, later answer అంతా ఆ style follow చేయడానికి context tracking ఉపయోగపడుతుంది.

7. Token cost — AI app economics

LLM APIs tokens basis లో charge చేస్తాయి. Input tokens + output tokens cost. Long conversation, large documents, verbose outputs — ఇవన్నీ cost increase చేస్తాయి.

ఎందుకు important?
Prototype లో cost small గా కనిపిస్తుంది. But 10,000 users daily use చేస్తే cost suddenly huge అవుతుంది.

Cost పెరగడానికి reasons:

• Long chat history repeatedly send చేయడం
• Unnecessary full documents prompt లో పెట్టడం
• Very large output generate చేయించడం
• Expensive model simple tasks కి use చేయడం
• RAG retrieval too many chunks పంపించడం

How to manage?

• Conversation summary maintain చేయడం
• Relevant chunks only send చేయడం
• Small model for simple tasks, big model for complex tasks
• Max tokens limit పెట్టడం
• Caching use చేయడం
• Prompt concise గా design చేయడం
• Evaluation ద్వారా unnecessary steps remove చేయడం

Use case:
Customer support bot లో greeting, simple FAQ కి cheaper model. Complex escalation కి stronger model. ఇలా routing చేస్తే cost control అవుతుంది.

8. RAG — company/private data తో grounded answers

RAG full form Retrieval-Augmented Generation. ఇది LLM ని company knowledge తో connect చేసే practical pattern.

Problem:
Base LLM కి company internal docs తెలియవు. Also model guess చేస్తే hallucination. Company-specific answers కి trusted source కావాలి.

RAG pipeline:

1. Documents collect చేస్తారు — PDFs, Notion pages, website docs, DB records
2. Text clean చేస్తారు
3. Text ని chunks గా split చేస్తారు
4. ప్రతి chunk కి embedding generate చేస్తారు
5. Vector DB లో embeddings + metadata store చేస్తారు
6. User query embedding generate చేస్తారు
7. Similar chunks retrieve చేస్తారు
8. Retrieved context prompt లో model కి ఇస్తారు
9. Model context ఆధారంగా answer generate చేస్తుంది

Chunking ఎందుకు important?
Full document model కి పంపితే costly and noisy. చిన్న meaningful chunks అయితే relevant information retrieve అవుతుంది.

Metadata ఎందుకు?
Document title, date, department, access permissions వంటి metadata filtering కి ఉపయోగపడుతుంది.

Use case:
Telusko chatbot: “Agentic AI course లో MCP ఎప్పుడు వస్తుంది?” అని అడిగితే, course notes/docs నుంచి MCP related chunks retrieve చేసి answer ఇవ్వాలి.

Limitation:
RAG కూడా perfect కాదు. Bad chunking, old documents, wrong retrieval, missing permissions ఉంటే answer quality పడిపోతుంది.

9. Vector DB — meaning-based search engine

Vector DB embeddings store చేసి similarity search చేస్తుంది. Traditional DB exact match కి strong; Vector DB semantic match కి strong.

ఎందుకు కావాలి?
User language and document language same ఉండకపోవచ్చు.

Example:

• Document: “refund eligibility”
• User: “money back rules”
• Keyword search miss అవ్వచ్చు
• Vector search meaning match చేయగలదు

Vector DB లో usually ఏమి store చేస్తారు?

• embedding vector
• original text chunk
• source document URL/id
• metadata
• permissions info
• timestamps/version info

Search ఎలా జరుగుతుంది?

1. User query embedding అవుతుంది
2. Vector DB nearest vectors find చేస్తుంది
3. Top K chunks return చేస్తుంది
4. Model వాటిని context గా use చేస్తుంది

Use cases:

• Internal knowledge assistant
• Product documentation search
• Legal document Q&A
• Course recommendation bot
• Support ticket similarity search

10. MCP — tools integration కి common standard

MCP అంటే Model Context Protocol. ఇది agents/tools మధ్య communication కి standard interface ఇవ్వడానికి useful.

Problem before MCP:
ప్రతి tool integration custom. GitHub కి ఒక style, Slack కి ఒక style, database కి ఇంకొక style. Agent developers కి integration maintenance burden.

MCP idea:
Tools ని standardized way లో expose చేయాలి. Agent tools list తెలుసుకుని, required tool call చేయాలి.

ఎలా use చేస్తారు?

1. MCP server tools provide చేస్తుంది
2. Agent available tools discover చేస్తుంది
3. User intent బట్టి right tool select చేస్తుంది
4. Tool input structured గా పంపుతుంది
5. Tool output తీసుకుని reasoning continue చేస్తుంది

Use cases:

• GitHub repo read/write
• Slack messages search/post
• Database records query/update
• File system read/write
• CRM data fetch
• Calendar scheduling

Important caution:
Tool calling actions dangerous కావచ్చు. Delete, send email, update database వంటి actions కి permissions, confirmations, audit logs అవసరం.

11. Prompt engineering — model behavior ని shape చేయడం

Prompt engineering అంటే model కి task, role, constraints, context, output format clearly చెప్పడం.

Bad prompt:
“Explain RAG.”

Better prompt:
“You are teaching a beginner. Explain RAG in Telugu-English mix, include why it was developed, how it works, one real company chatbot use case, and limitations. Use bullets.”

ఎందుకు important?
LLM flexible. Good prompts లేకపోతే output inconsistent. Application లో consistency కావాలి.

Good prompt components:

• Role: “You are a senior AI engineer”
• Audience: “Beginner software developers”
• Context: “Based on these course notes”
• Task: “Explain concepts”
• Constraints: “Don’t invent facts”
• Format: “Use headings and bullets”
• Examples: one-shot/few-shot
• Tone: “Colloquial Telugu-English mix”

Prompt techniques:

• Zero-shot: example లేకుండా direct task
• One-shot: ఒక example తో
• Few-shot: multiple examples తో
• Structured prompting: fixed JSON/table/bullets format
• Constraint prompting: do/don’t rules
• Contextual prompting: extra background ఇవ్వడం

Use case:
YouTube script generator లో title generation, title selection, script generation, script evaluation — ప్రతి step కి different prompt and role ఇవ్వడం వల్ల pipeline controlled అవుతుంది.

12. Agents — chatbot కంటే next level

Agent అంటే LLM + reasoning + memory/context + tools + goal-oriented workflow.

Chatbot vs Agent:

• Chatbot mostly answer ఇస్తుంది
• Agent task plan చేసి tools use చేసి action complete చేస్తుంది

Agent high-level loop:

1. User goal understand చేస్తుంది
2. Task ని steps గా break చేస్తుంది
3. అవసరమైన data/tools identify చేస్తుంది
4. Tool calls చేస్తుంది
5. Results evaluate చేస్తుంది
6. అవసరమైతే next step decide చేస్తుంది
7. Final answer/action complete చేస్తుంది

Use case:
“నా meeting transcript నుంచి action items తీసుకుని task tracker లో create చేయి.”
Agent transcript read చేస్తుంది, action items extract చేస్తుంది, assignee/due date infer లేదా ask చేస్తుంది, task database లో rows create చేస్తుంది.

Important caution:
Agents autonomous కాబట్టి guardrails must: permissions, confirmations, rate limits, logging, rollback, user approval.

This is a reference list of tools and libraries. Some of these may not be used or referred to during the course.

I have decided to take up this course :  https://iitmpravartak.emeritus.org/professional-certificate-programme-in-agentic-ai-and-applications

Why I’m Taking This Course: A Developer’s Perspective

1. Evolution from Prompting to Autonomous AI

After years of building systems, web apps, and integrations, I’ve witnessed AI evolve into something more dynamic. Traditional models respond; Agentic AI acts autonomously, pursues multi-step objectives, adapts, and reasons—unlocking a new tier of intelligent systems.

2. Hands-On Tool Experience

The programme emphasizes practical learning via tools like LangChain, CrewAI, Flowise, ChromaDB, FAISS, and LLM pipelines—far beyond theory.

3. Real-World Learning Through Projects & Capstone

The 20+ graded assignments and the culminating capstone project offer real, applied experience—an ideal fit for professionals who value learning by doing.

4. Certification for Credibility

Graduating participants earn three IBM certifications (AI Agent Building, Generative AI for Business, Responsible AI), alongside an IITM Pravartak certificate—a powerful combination of academic and industry recognition.

5. Designed for Professionals Like Me

The schedule blends live online sessions with self-paced learning, ideal for someone balancing full-time work commitments.

6. Networking with Thought-Leadership

From guest masterclasses by IITM faculty to an optional immersion at the IITM Research Park, this is a unique chance to interact with peers and mentors

Programme Modules