Thursday, November 6

๐Ÿง  Tutorial: “Master SQL Using Perplexity AI — From Beginner to Pro” by Ajay Architect

⏱ Tutorial Duration: 15–30 minutes approximate 

๐Ÿ’ก Goal:  Teach how to use AI tools like Perplexity, ChatGPT or Gemini to write, optimize, and analyze SQL queries — without manual coding.


๐Ÿ”น 1. Understanding the Concept: SQL + AI

Traditional SQL writing involves:

SELECT customer_name, SUM(amount)   FROM orders  WHERE order_date >= '2025-01-01'  GROUP BY customer_name  ORDER BY SUM(amount) DESC;  

With AI tools, you can simply say:

๐Ÿ—ฃ️ "Show me the top 10 customers by total purchase value since January 2025."

AI converts this natural language into the above SQL automatically.

AI Advantage: You save hours of manual query building, debugging, and syntax lookup.


๐Ÿ”น 2. How to Use AI for SQL Generation

Example 1: Basic Data Extraction

๐Ÿ—ฃ️ Prompt to AI:

Write an SQL query to list all employees from the "Sales" department earning more than ₹70,000 per month.

๐Ÿงฉ AI Output:

SELECT name, department, salary  FROM employees  WHERE department = 'Sales'    AND salary > 70000;  

You can even ask AI to:

Convert this query for PostgreSQL / MySQL / BigQuery.


๐Ÿ”น 3. AI for Database Design

AI can also design database schemas for you.

๐Ÿ—ฃ️ Prompt:

Design a database for an e-commerce company with tables for customers, products, and orders.

๐Ÿงฉ AI Output:

CREATE TABLE customers (      customer_id INT PRIMARY KEY,      name VARCHAR(100),      email VARCHAR(100),      city VARCHAR(50)  );    CREATE TABLE products (      product_id INT PRIMARY KEY,      name VARCHAR(100),      category VARCHAR(50),      price DECIMAL(10,2)  );    CREATE TABLE orders (      order_id INT PRIMARY KEY,      customer_id INT,      product_id INT,      order_date DATE,      quantity INT,      FOREIGN KEY (customer_id) REFERENCES customers(customer_id),      FOREIGN KEY (product_id) REFERENCES products(product_id)  );  

AI saves hours by creating entire schema structures instantly.


๐Ÿ”น 4. Query Optimization Using AI

Example:

๐Ÿ—ฃ️ Prompt:

Optimize this query for faster performance.

SELECT * FROM orders WHERE customer_id IN (SELECT customer_id FROM customers WHERE city = 'Pune');  

๐Ÿงฉ AI Suggestion:

SELECT o.*  FROM orders o  JOIN customers c ON o.customer_id = c.customer_id  WHERE c.city = 'Pune';  

✅ AI explains: "JOINs are generally faster than subqueries."


๐Ÿ”น 5. Debug SQL Errors Using AI

๐Ÿ—ฃ️ Prompt:

Fix this query:

SELECT name, salary FROM employee WHERE salary => 50000;  

๐Ÿงฉ AI Correction:

SELECT name, salary FROM employee WHERE salary >= 50000;  

AI instantly spots syntax and logic errors.


๐Ÿ”น 6. AI-Powered Data Insights

Once you've data in your database, ask:

๐Ÿ—ฃ️ "Which city has the highest average sales in 2025?"

๐Ÿงฉ AI Output:

SELECT city, AVG(amount) AS avg_sales  FROM orders  WHERE YEAR(order_date) = 2025  GROUP BY city  ORDER BY avg_sales DESC  LIMIT 1;  

✅ Use this to automate reporting and dashboards.


๐Ÿ”น 7. AI for SQL Interview Prep

AI can simulate interview questions:

๐Ÿ—ฃ️ "Ask me 5 SQL interview questions with answers for a Data Analyst role."

๐Ÿงฉ Example Output:

  1. What is a Primary Key?
    A column (or group of columns) that uniquely identifies each record in a table.

    CREATE TABLE students (id INT PRIMARY KEY, name VARCHAR(50));  
  2. Difference between INNER JOIN and LEFT JOIN

    • INNER JOIN returns matching rows.
    • LEFT JOIN returns all rows from the left table, plus matched rows from the right.

…and so on.


๐Ÿ”น 8. Building a Full AI + SQL Project

๐Ÿงฉ Example: Sales Dashboard

AI can generate:

  1. SQL to extract data from orders
  2. Python code (using Pandas + SQLAlchemy)
  3. Chart commands for visualization

๐Ÿ—ฃ️ Prompt:

Build a small dashboard showing monthly revenue trends using SQL and Python.

✅ AI creates both SQL and Python scripts for you — saving 5+ hours of manual coding.


๐Ÿ”น 9. Tools You Can Use

  • Perplexity/ ChatGPT / Gemini / Claude — for SQL query generation and debugging
  • DigitalTechnologyArchitecture Blog — for live guided sessions
  • SQLBolt / Mode Analytics / DB Fiddle — to practice queries online
  • LeetCode SQL — to test optimization skills

๐Ÿ”น 10. Certification Path

I conduct workshops and at the end of such a workshop, you'll typically:

  • Complete hands-on exercises
  • Submit AI-generated SQL assignments
  • Get an industry-recognized certificate

๐ŸŽ“ Example:

"Certified SQL Using AI Professional – AI for SQL Developers"


✅ Summary - HOw SQL developer can save time using AI?

Task Traditional Time With AI
Write query 30 mins 1–2 mins
Design schema 2 hrs 5 mins
Optimize SQL 1 hr Instant
Debug errors 45 mins Seconds
Interview prep 3 hrs 15 mins

๐Ÿ’ก Total time saved: 5 hours → 15 minutes

Feel free to share the tutorial with your friends and visit agin for more quick tutorial on AI 
For workshop write to projectncharge@yahoo.com or smartmobileideas@gmail.com 
Enjoy! - Ajay Architect 

Thursday, September 18

Enhancing Traditional Architecture for AI: A Guide by an Enterprise IT Architect


Enhancing Traditional Architecture for AI: A Guide by an Enterprise IT Architect

Introduction

With decades shaping large-scale systems at Google and Microsoft, I’ve seen AI go from experimental to foundational. For many organizations running stable 4-tier or SOA architectures, the key question is: How do we integrate AI safely, transparently, and sustainably? In this guide, I outline a refined architectural approach for embedding AI — not as an afterthought, but as a first-class, governed capability.

1. Ground What’s Proven: The 4-Tier Architecture

The familiar pattern holds:

  • Client/UI – Web, mobile, or desktop.

  • Presentation/API – Gateways, controllers, entry points.

  • Application/Services – Business logic, orchestration.

  • Data Tier – Databases, caches, storage.

This modular structure remains solid. The challenge: augment, not disrupt.


2. Why AI Works Best as a Layered Service

Based on enterprise best practices:

  • SOA compatibility: AI fits naturally as a loosely coupled, contract-based service .

  • Modular AI Services: Package models as APIs behind SLAs, support versioning, autoscale independently — just like Google/Microsoft deploy theirs 

  • Semantic Enrichment: Introduce a “Knowledge Layer” (e.g., RAG or ontology-backed context) that grounds AI across data silos and documents 


3. Diagram Inspiration

 

Top ImageSemantic Layer Architecture

From Enterprise Knowledge: illustrates how businesses embed AI understanding into structured datasets (taxonomies, ontologies, knowledge graphs), enabling richer semantic context across services.

Bottom ImageLayered Enterprise AI Blueprint

From Infosys: presents a multi-layer AI reference architecture — from infrastructure and engineering processes to governance — that bridges AI and traditional IT infrastructure.


4. Core Architectural Patterns

4a. Treat AI Models as First-Class Services

  • Wrap inference models in versioned microservices (REST/gRPC).

  • Use tools like KServe or Seldon for model serving, autoscaling, and canary deploys (DEV Community).

4b. Data-Centric, Event-Driven Pipelines

  • Use streaming platforms (e.g., Kafka) to feed models real-time events.

  • Store features in feature stores (e.g., Feast, Tecton) for consistency across training and inference (DEV Community).

4c. Semantic / Knowledge Layer

  • Integrate knowledge graphs or ontologies to enrich AI context.

  • Empower grounded AI responses using structured business knowledge (LinkedIn).

4d. SOA + AI Synergy with Governance

  • Use principles like service composability and loose coupling to manage AI services (Wikipedia).

  • Embed observability, privacy, and lifecycle tracking.

4e. Evolving Toward Agentic AI

  • McKinsey highlights the rise of “agentic meshes”: autonomous AI agents that operate cooperatively and continuously, beyond single-model responses (TechRadar).

  • Architecting for them means enabling real-time data, shared memory, auditability, and control.


5. Enterprise Deployment Blueprint

Component Enterprise Enhancement
AI Infrastructure Cloud/on-prem orchestration, GPU/autoscaling, unified model deployment 
Model Services Containerized, versioned, API-first deployments (KServe, CI/CD integration)
Data Pipelines Event ingestion, feature stores, feedback loops for model retraining
Knowledge Layer Ontologies, knowledge graphs, taxonomy services for context grounding 
SOA Governance Contracts, policy enforcement, audit logs, reuse policies
Agentic Readiness Support event-driven services, real-time APIs, memory, and orchestration layers

6. Deployment Roadmap

  1. Pilot – Weeks 0–4: Select a high-impact AI use case (e.g., intelligent search or auto summarization). Deploy standalone service behind API gateway, with observability and SLAs.

  2. Integration – Weeks 5–8: Add feature pipelines, connect knowledge layer, integrate with SOA services.

  3. Governance – Weeks 9–12: Build monitoring dashboards (latency, cost, bias), establish model registry, and audit logs.

  4. Agentic Transition – Months 3–6: Lay groundwork for autonomous agents, real-time event triggers, and shared memory patterns.


Conclusion

As an architect with Google and Microsoft DNA, I've seen firsthand that true enterprise AI isn’t about smarter models — it’s about smarter systems. Begin with the strong foundation you already have, layer AI services thoughtfully, anchor them with data, semantics, and governance — and then, as maturity grows, evolve toward agentic, autonomous orchestration.

This is not just an AI feature, but a strategic architectural commitment.

Let me know if you’d like me to craft fully polished diagrams (SVG-style) or tailor this for a whitepaper or executive summary.


How AI Can Assist You in Your Legal Case

Artificial Intelligence (AI) can be a helpful assistant in preparing for legal matters. By scanning through lakhs of cases across India and the world, AI can highlight judgments that support your side, point out possible weaknesses in your opponent's case, and suggest strategic directions.

Below are some simple ways to use AI with example prompts:


Step 1: Upload Your Case Document

If you have your case details in a PDF file, you can upload it into an AI tool (like ChatGPT). Once uploaded, you can ask AI to:

Example Prompt 1:
"I am uploading my case PDF. Please summarize the key facts, main issues, and what relief is being sought."

Example Prompt 2:
"Highlight the timeline of events in this case PDF in a simple table format."

Example Prompt 3:
"Please identify the main legal sections and acts referred to in this case."


Step 2: Find Supporting Cases

AI can search legal databases and identify cases that are similar to yours.

Example Prompt 4:
"Based on this uploaded case PDF, please list 5 Indian Supreme Court judgments that support my arguments. Provide case names and short summaries."

Example Prompt 5:
"Please find global case references (UK, US, etc.) that may strengthen my side of the argument."

Example Prompt 6:
"List any High Court judgments from the last 10 years that are relevant to my case facts."

Example Prompt 7:
"Compare my case PDF with [insert case name] and tell me how they are similar or different."


Step 3: Identify Weak Points in Opponent's Case

AI can act like a neutral checker and point out where your opponent might attack.

Example Prompt 8:
"Please analyze this case PDF and highlight potential weak points that my opponent's lawyer may raise."

Example Prompt 9:
"List the possible counterarguments that the other side may use against my claims."

Example Prompt 10:
"Check if any legal precedents exist that could weaken my case position."


Step 4: Strategy Recommendations

Once strengths and weaknesses are identified, you can ask AI for possible strategies.

Example Prompt 11:
"Given the facts of my case and the legal precedents, suggest 3 strategic approaches that my lawyer can use in court."

Example Prompt 12:
"If the opponent argues XYZ, suggest counterarguments supported by legal precedents."

Example Prompt 13:
"Please create a list of questions my lawyer can ask during cross-examination to strengthen my position."

Example Prompt 14:
"Draft a sample written submission based on the uploaded case facts and supporting case law."


Step 5: Simplify Legal Language

Legal documents are often complex. AI can explain them in simple terms.

Example Prompt 15:
"Please explain the uploaded case PDF in simple language as if explaining to a 10-year-old."

Example Prompt 16:
"Summarize this legal section (IPC/Act) in plain English/Marathi/Hindi."

Example Prompt 17:
"Give me a bullet-point explanation of this judgment for a non-lawyer."


Step 6: Practical Preparation

You can also use AI for practical legal preparation.

Example Prompt 18:
"Create a checklist of documents and evidence I should collect based on my case PDF."

Example Prompt 19:
"Suggest a timeline for next steps in my legal process (filing, hearings, appeals)."

Example Prompt 20:
"Draft possible questions I should ask my lawyer when we meet to discuss this case."


Important Note

AI is not a substitute for a qualified lawyer. It is a research and support tool to help you prepare better, understand your case more clearly, and explore different strategies.


In Short:

  • Upload your case PDF.
  • Ask AI to summarize, find similar cases, and identify weaknesses.
  • Use AI to test arguments, draft strategies, and simplify legal terms.
  • Always discuss the final plan with your lawyer.

This way, AI becomes your legal assistant – working tirelessly to scan lakhs of cases and helping you prepare smarter.


Friday, August 29

เคช्เคฐॉเคฎ्เคช्เคŸ เค‡ंเคœिเคจिเค…เคฐिंเค—: เคธเคตिเคธ्เคคเคฐ เคฎाเคฐ्เค—เคฆเคฐ्เคถเค• (เค‰เคฆाเคนเคฐเคฃांเคธเคน)

เคฎी เคนा เคฒेเค– เค•ृเคค्เคฐिเคฎ เคฌुเคฆ्เคงिเคฎเคค्เคคा (Artificial Intelligence) เค†เคฃि เคคिเคšा เคตाเคชเคฐ เค•เคธा เค•เคฐाเคตा เคฏाเคฌเคฆ्เคฆเคฒ เคฒिเคนिเคฒा เค†เคนे, เคœेเคฃेเค•เคฐूเคจ เค‡ंเค—्เคฐเคœीเคค เคธเคนเคœ เคฌोเคฒू เคจ เคถเค•เคฃाเคฑ्เคฏा เค†เคชเคฒ्เคฏा เคฎเคฐाเค ी เคฌांเคงเคตांเคจा เคธोเคช्เคฏा เคญाเคทेเคค AI เคถिเค•เคคा เคฏेเคˆเคฒ. เคญเคตिเคท्เคฏाเคค เคคुเคฎ्เคนाเคฒा AI เคตिเคทเคฏเค• เค…เคœूเคจ เคชोเคธ्เคŸ्เคธ เคฎเคฐाเค ीเคค เคชाเคนाเคฏเคฒा เคฎिเคณเคคीเคฒ. เค•ृเคชเคฏा เคนा เคฒेเค– เค†เคชเคฒ्เคฏा เคฎเคฐाเค ी เคฎिเคค्เคฐ, เคตिเคฆ्เคฏाเคฐ्เคฅी เค†เคฃि เคœ्เคฏेเคท्เค  เคจाเค—เคฐिเค•ांเคชเคฐ्เคฏंเคค เคชोเคนोเคšเคตा, เคœेเคฃेเค•เคฐूเคจ เคค्เคฏांเคจाเคนी AI เคถिเค•เคคा เคฏेเคˆเคฒ.  เคœเคจเคฐेเคŸिเคต्เคน (Generative) AI เคš्เคฏा เค•ाเคณाเคค, เคช्เคฐॉเคฎ्เคช्เคŸ เค‡ंเคœिเคจिเค…เคฐिंเค— เคนे เค•ौเคถเคฒ्เคฏ AI เคถी เคช्เคฐเคญाเคตीเคชเคฃे เคธंเคตाเคฆ เคธाเคงเคฃ्เคฏाเคธाเค ी เคธเคฐ्เคตाเคค เค†เคตเคถ्เคฏเค• เค เคฐเคฒे เค†เคนे.

๐Ÿ‘‰ เค‡ंเค—्เคฐเคœी เค†เคตृเคค्เคคीเคธाเค ी เคฒिंเค•:  Read Prompt Engineering in English

เคœเคจเคฐेเคŸिเคต्เคน AI เคฎ्เคนเคฃเคœे เค•ाเคฏ?

  • AI (เค•ृเคค्เคฐिเคฎ เคฌुเคฆ्เคงिเคฎเคค्เคคा) เคฎ्เคนเคฃเคœे เคธंเค—เคฃเค•ाเคฒा เคฎाเคฃเคธाเคธाเคฐเค–ं เคตिเคšाเคฐ เค•เคฐाเคฏเคฒा, เคถिเค•ाเคฏเคฒा เค†เคฃि เคจिเคฐ्เคฃเคฏ เค˜्เคฏाเคฏเคฒा เคถिเค•เคตเคฃं.

  • Generative AI เคฎ्เคนเคฃเคœे เค…เคถी เค•ृเคค्เคฐिเคฎ เคฌुเคฆ्เคงिเคฎเคค्เคคा เคœी เคธ्เคตเคคःเคนूเคจ เคจเคตीเคจ เค—ोเคท्เคŸी เคคเคฏाเคฐ เค•เคฐू เคถเค•เคคे

เคธोเคชं เค‰เคฆाเคนเคฐเคฃ

เคœเคฐ เคคुเคฎ्เคนी เคเค–ाเคฆ्เคฏा เคฎिเคค्เคฐाเคฒा เคธांเค—िเคคเคฒंเคค เค•ी, “เคฎเคฒा เคธिंเคนाเคšं เคšिเคค्เคฐ เค•ाเคขूเคจ เคฆाเค–เคต.”  เคคो เคฎिเคค्เคฐ เคธ्เคตเคคः เค•เคฒ्เคชเคจा เค•เคฐूเคจ เคธिंเคนाเคšं เคšिเคค्เคฐ เค•ाเคขूเคจ เคฆेเคˆเคฒ. Generative AI เคชเคฃ เคคเคธंเคš เค†เคนे — เคคुเคฎ्เคนी เคค्เคฏाเคฒा prompt (เคฎ्เคนเคฃเคœे เคธूเคšเคจा/เคฎाเค—เคฃी) เคฆेเคคा, เค†เคฃि เคคी AI เคจเคตीเคจ เคฎเคœเค•ूเคฐ, เคšिเคค्เคฐ เค•िंเคตा เคธंเค—ीเคค เคคเคฏाเคฐ เค•เคฐूเคจ เคฆेเคคे.

เคšเคฒा เค†เคคा Prompt Engineering เคฎ्เคนเคฃเคœे เค•ाเคฏ, เคช्เคฐॉเคฎ्เคช्เคŸ เค•เคธा เคฒिเคนाเคฏเคšा เค†เคฃि เคฎเค— เค†เคœเคชाเคธूเคจเคš ChatGPT เคฌเคฐोเคฌเคฐ เคค्เคฏाเคšा เคตाเคชเคฐ เค•เคธा เคธुเคฐू เค•เคฐाเคฏเคšा เคคे เคชाเคนूเคฏा!  เฅงเฅฆ เคตเคฐ्เคทांเคš्เคฏा เคฎुเคฒाเคชाเคธूเคจ เคคे เฅญเฅฏ เคตเคฐ्เคทांเคš्เคฏा เคœ्เคฏेเคท्เค ांเคชเคฐ्เคฏंเคค เคช्เคฐเคค्เคฏेเค•เคœเคฃ เค†เคชเคฒ्เคฏा เคฎोเคฌाเคˆเคฒเคตเคฐूเคจ เคนे เคธเคนเคœ เคตाเคชเคฐू เคถเค•เคคो.
เคคेเคตเคขं เคนे เคธोเคชं เค†เคนे!


เคจเคตเคถिเค•्เคฏांเคธाเค ी เฅฉ เคฒोเค•เคช्เคฐिเคฏ AI เคธाเคงเคจे เคฎ्เคนเคฃเคœे –

  1. ChatGPT (OpenAI เคšे) - Open chatgpt

  2. Gemini (Google เคšे)

  3. Claude (Anthropic เคšे)


เคนे เค•ृเคค्เคฐिเคฎ เคฌुเคฆ्เคงिเคฎเคค्เคคा (AI) เคจेเคฎเค•े เค•เคธे เค•ाเคฎ เค•เคฐเคคे?

  1. เคคुเคฎ्เคนाเคฒा เคฎाเคนीเคค เค†เคนेเคš เค•ी เคธंเค—เคฃเค•ाเคตเคฐ เคธॉเคซ्เคŸเคตेเค…เคฐ เคšाเคฒเคคे, เคคो เค‡ंเคŸเคฐเคจेเคŸเคตเคฐ เคถोเคง เค˜ेเคŠ เคถเค•เคคो เค†เคฃि เคกेเคŸा เคธाเค เคตू เคถเค•เคคो.

  2. เฅงเฅฆ,เฅฆเฅฆเฅฆ เคธंเค—เคฃเค• เฅง เคธंเค—เคฃเค•ाเคชेเค•्เคทा เค•िเคคीเคคเคฐी เคชเคŸ เคตेเค—ाเคจे เค‡ंเคŸเคฐเคจेเคŸเคตเคฐ เคถोเคง เค˜ेเคŠ เคถเค•เคคाเคค เคต เคฎाเคนिเคคी เคธाเค เคตू เคถเค•เคคाเคค.

  3. เคœเคฐ เคฎी เคธंเค—เคฃเค•ाเคฒा "เคกॉเคฒ्เคซिเคจ" เค•िंเคตा "เค•ॉเคซी" เคฌเคฆ्เคฆเคฒ เคฎाเคนिเคคी เคถोเคงाเคฏเคฒा เคธांเค—िเคคเคฒे, เคคเคฐ เคคो เคธเค—เคณी เคฎाเคนिเคคी เคธाเค เคตเคคो เค†เคฃि เคœेเคต्เคนा เคฎी เคช्เคฐเคถ्เคจ เคตिเคšाเคฐเคคो, เคคेเคต्เคนा เค•ाเคนी เคธेเค•ंเคฆांเคค เค‰เคค्เคคเคฐ เคฆेเคคो.

  4. AI เค…เคธंเคš เค•ाเคฎ เค•เคฐเคคं – เคฒाเค–ो เคธंเค—เคฃเค• เคตिเคถिเคท्เคŸ "เคถเคฌ्เคฆांเคฌเคฆ्เคฆเคฒ" เคฎाเคนिเคคी เคถोเคงเคคाเคค เคต เคธाเค เคตเคคाเคค เค†เคฃि เค†เคชเคฃ เคช्เคฐเคถ्เคจ เคตिเคšाเคฐเคฒ्เคฏाเคตเคฐ เคคे เคธेเค•ंเคฆाเคค เค‰เคค्เคคเคฐ เคฆेเคคाเคค.

  5. เคช्เคฐॉเคฎ्เคช्เคŸ เค‡ंเคœिเคจिเค…เคฐिंเค— เคฎ्เคนเคฃเคœे เคธंเค—เคฃเค•ाเคฒा เค…เคธा เค†เคฆेเคถ (เค•เคฎांเคก) เคฒिเคนिเคฃे เคœ्เคฏाเคฎुเคณे เคค्เคฏाเคฒा เคจेเคฎเค•े เค•ाเคฏ เคนเคตे เค†เคนे เคคे เคธเคฎเคœेเคฒ เค†เคฃि เคคो เคธเคฐ्เคตोเคค्เคคเคฎ เค‰เคค्เคคเคฐ เคฆेเคˆเคฒ.

  6. เคœเคฐ เคฎเคฒा เฅงเฅฆ เคตเคฐ्เคทांเคš्เคฏा เคฎुเคฒाเคฒा "เค•ॉเคซी เค•เคถी เคฌเคจเคตเคคाเคค" เคนे เคธเคฎเคœाเคตूเคจ เคธांเค—ाเคฏเคšे เค…เคธेเคฒ, เคคเคฐ เคธंเค—เคฃเค•ाเคฒा เคคเคถी เคธूเคšเคจा เคฆ्เคฏाเคตी เคฒाเค—ेเคฒ, เคœ्เคฏाเคฎुเคณे เคค्เคฏाเคšे เค‰เคค्เคคเคฐ เคค्เคฏा เคฎुเคฒाเคฒा เคธเคนเคœ เคธเคฎเคœेเคฒ.

  7. เคชเคฃ เคœเคฐ เคฎเคฒा เฅฉเฅฆ เคตเคฐ्เคทांเคš्เคฏा เคต्เคฏเค•्เคคीเคฒा "เค˜เคฐी เคฌ्เคฐू เค•ॉเคซी เค•เคถी เคฌเคจเคตเคคाเคค" เคนे เคตिเคšाเคฐाเคฏเคšे เค…เคธेเคฒ, เคคเคฐ เคฎी เคตेเค—เคณ्เคฏा เคช्เคฐเค•ाเคฐे เคช्เคฐเคถ्เคจ เคตिเคšाเคฐเคฒा เคชाเคนिเคœे.

  8. เคœिเคคเค•ा เคœाเคธ्เคค เคธंเคฆเคฐ्เคญ (Context) เคคुเคฎ्เคนी เคฆ्เคฏाเคฒ, เคคिเคคเค•ं AI เค•เคกूเคจ เคฎिเคณเคฃाเคฐं เค‰เคค्เคคเคฐ เคšांเค—เคฒं เคฏेเคˆเคฒ.


เคตाเคšเคจ เคธुเคฐू เค•เคฐเคฃ्เคฏाเคชूเคฐ्เคตी เค•ाเคนी เคช्เคฐเคถ्เคจ

  • เคธाเคง्เคฏा เคฎाเคฃเคธाเคฒा AI เคธाเคงเคจांเคถी เคฌोเคฒूเคจ เคšांเค—เคฒे เค‰เคค्เคคเคฐ เคฎिเคณू เคถเค•ेเคฒ เค•ा?

  • เคฌाเคฏเค•ो, เค†เคˆ, เคตिเคฆ्เคฏाเคฐ्เคฅी, เคตเค•ीเคฒ, เคกॉเค•्เคŸเคฐ, เคถेเคซ เคฏांเคš्เคฏा เค†เคฏुเคท्เคฏाเคค เค•ृเคค्เคฐिเคฎ เคฌुเคฆ्เคงिเคฎเคค्เคคेเคšा เค•ाเคนी เค‰เคชเคฏोเค— เค†เคนे เค•ा?

  • เคฎी เค†เคœเคชाเคธूเคจ AI เคตाเคชเคฐाเคฏเคฒा เคธुเคฐूเคตाเคค เค•เคฐू เคถเค•เคคो เค•ा?

  • เคฎी เฅญเฅฏ เคตเคฐ्เคทांเคšा เค†เคนे – เคคเคฐी AI เคฎเคฒा เคฎเคฆเคค เค•เคฐू เคถเค•ेเคฒ เค•ा?

เคตเคฐीเคฒ เคธเคฐ्เคต เคช्เคฐเคถ्เคจांเคšी เค‰เคค्เคคเคฐे = เคนोเคฏ ✅


เคช्เคฐॉเคฎ्เคช्เคŸ เค‡ंเคœिเคจिเค…เคฐिंเค— เคฎ्เคนเคฃเคœे เค•ाเคฏ?

เคช्เคฐॉเคฎ्เคช्เคŸ เค‡ंเคœिเคจिเค…เคฐिंเค— เคฎ्เคนเคฃเคœे AI เคฒा เค…เคถी เค‡เคจเคชुเคŸ เคฒिเคนिเคฃ्เคฏाเคšी เคช्เคฐเค•्เคฐिเคฏा เคœ्เคฏाเคฎुเคณे เค…เคชेเค•्เคทिเคค, เค‰เคชเคฏुเค•्เคค เคต เค…เคšूเค• เค‰เคค्เคคเคฐ เคฎिเคณเคคे. ChatGPT เคธाเคฐเค–ी เคฎॉเคกेเคฒ्เคธ เคช्เคฐเคšंเคก เคกेเคŸाเคธेเคŸเคฎเคงीเคฒ เคชॅเคŸเคฐ्เคจ्เคธเคตเคฐ เค†เคงाเคฐिเคค เค‰เคค्เคคเคฐ เคคเคฏाเคฐ เค•เคฐเคคाเคค. เคฎ्เคนเคฃूเคจ เค†เคชเคฃ เคช्เคฐเคถ्เคจ เค•เคธा เคตिเคšाเคฐเคคो, เคฏाเคตเคฐ เค‰เคค्เคคเคฐ เคฌเคฑ्เคฏाเคš เคช्เคฐเคฎाเคฃाเคค เค…เคตเคฒंเคฌूเคจ เค…เคธเคคे.

เคฎुเคณाเคค, เคช्เคฐॉเคฎ्เคช्เคŸ เค‡ंเคœिเคจिเค…เคฐिंเค— เคฎ्เคนเคฃเคœे:

  • ChatGPT เค•िंเคตा Gemini เค‡เคจเคชुเคŸ เค•เคธा เคธเคฎเคœเคคाเคค เคนे เคœाเคฃूเคจ เค˜ेเคฃे.

  • เคฎॉเคกेเคฒเคš्เคฏा เคตเคฐ्เคคเคจाเคฒा เคฆिเคถा เคฆेเคฃाเคฐे เคช्เคฐॉเคฎ्เคช्เคŸ्เคธ เคคเคฏाเคฐ เค•เคฐเคฃे.

  • เคชเคฐिเคฃाเคฎ เคธुเคงाเคฐเคฃ्เคฏाเคธाเค ी เคช्เคฐॉเคฎ्เคช्เคŸ्เคธเคฎเคง्เคฏे เคธเคคเคค เคธुเคงाเคฐเคฃा เค•เคฐเคฃे.


เคช्เคฐॉเคฎ्เคช्เคŸ เค‡ंเคœिเคจिเค…เคฐिंเค— เค•ा เคฎเคนเคค्เคตाเคšे เค†เคนे?

AI เคฎॉเคกेเคฒ्เคธ เคถเค•्เคคिเคถाเคฒी เค…เคธเคคाเคค, เคชเคฃ เคคे เคตिเคšाเคฐ เคตाเคšू เคถเค•เคค เคจाเคนीเคค. เคคे เคซเค•्เคค เคฆिเคฒेเคฒ्เคฏा เคฎเคœเค•ुเคฐाเคตเคฐ เค…เคตเคฒंเคฌूเคจ เค…เคธเคคाเคค.
เคถเคฌ्เคฆเคฐเคšเคจा, เคŸोเคจ, เคคเคชเคถीเคฒ, เคฐเคšเคจा เคฏाเคฎเคงीเคฒ เค›ोเคŸाเคธा เคซเคฐเค•เคนी เคชเคฐिเคฃाเคฎ เคฌเคฆเคฒू เคถเค•เคคो.

เคšांเค—เคฒ्เคฏा เคช्เคฐॉเคฎ्เคช्เคŸ เค‡ंเคœिเคจिเค…เคฐिंเค—เคšे เคซाเคฏเคฆे:

  • เค…เคงिเค• เค…เคšूเค• เคต เคธंเคฌंเคงिเคค เค‰เคค्เคคเคฐे

  • เคšुเค•ीเคšी เค•िंเคตा เค•ाเคฒ्เคชเคจिเค• เคฎाเคนिเคคी เค•เคฎी เคนोเคฃे

  • เคตेเคณेเคšी เคฌเคšเคค

  • เคถैเค•्เคทเคฃिเค•, เคต्เคฏाเคตเคธाเคฏिเค• เค•िंเคตा เคธเคฐ्เคœเคจเคถीเคฒ เค‰เคฆ्เคฆिเคท्เคŸांเคถी เค…เคงिเค• เคธुเคธंเค—เคค เค‰เคค्เคคเคฐे


เคช्เคฐॉเคฎ्เคช्เคŸ เค‡ंเคœिเคจिเค…เคฐिंเค—เคšी เคฎूเคฒเคญूเคค เคคเคค्เคค्เคตे

  1. เคธ्เคชเคท्เคŸเคคा (Clarity)

    • เคช्เคฐॉเคฎ्เคช्เคŸ เคœिเคคเค•ा เคธ्เคชเคท्เคŸ, เค‰เคค्เคคเคฐ เคคिเคคเค•े เคธ्เคชเคท्เคŸ.

    • เค—ोंเคงเคณ เคŸाเคณा.

  2. เคตिเคถिเคท्เคŸเคคा (Specificity)

    • เคช्เคฐॉเคฎ्เคช्เคŸ เคœिเคคเค•ा เคจेเคฎเค•ा, เค‰เคค्เคคเคฐ เคคिเคคเค•ं เคšांเค—เคฒं.

    • เคซॉเคฐเคฎॅเคŸ, เคŸोเคจ, เคฒांเคฌी เค•िंเคตा เคฆृเคท्เคŸिเค•ोเคจ เคฒिเคนा.

  3. เคธंเคฆเคฐ्เคญ (Contextualization)

    • เคชाเคฐ्เคถ्เคตเคญूเคฎी เคฆिเคฒ्เคฏाเคธ เค…เคงिเค• เคฏोเค—्เคฏ เค‰เคค्เคคเคฐ เคฎिเคณเคคे.

  4. เคธूเคšเคจाเคค्เคฎเค• เคญाเคทा (Instructional Language)

    • "List", "Summarize", "Compare" เคธाเคฐเค–ी เค•्เคฐिเคฏाเคชเคฆे เคตाเคชเคฐा.

  5. เคชुเคจเคฐाเคตृเคค्เคคी (Iteration)

    • เค‰เคค्เคคเคฐे เคคเคชाเคธा เคต เค†เคตเคถ्เคฏเค•เคคेเคจुเคธाเคฐ เคช्เคฐเคถ्เคจ เคชुเคจ्เคนा เคฒिเคนा.


เคช्เคฐॉเคฎ्เคช्เคŸ्เคธเคšे เคช्เคฐเค•ाเคฐ

  1. เคตเคฐ्เคฃเคจाเคค्เคฎเค• (Descriptive)

    • "เคฎंเค—เคณ เค—्เคฐเคนाเคšे เคตाเคคाเคตเคฐเคฃ เคตเคฐ्เคฃเคจ เค•เคฐा."

    • "เคธเคช्เคŸेंเคฌเคฐ เฅจเฅฆเฅจเฅฌ เคฎเคง्เคฏे เคนเคตाเคˆเคšे เคนเคตाเคฎाเคจ เค•เคธे เค…เคธेเคฒ?"

  2. เคธूเคšเคจाเคค्เคฎเค• (Instructional)

    • "เคเคฐोเคช्เคฒेเคจ เค•เคธे เค•ाเคฎ เค•เคฐเคคे เคคे เฅจ เคชเคฐिเคš्เค›ेเคฆांเคค เคธเคฎเคœเคตा."

  3. เคธเคฐ्เคœเคจเคถीเคฒ (Creative)

    • "เฅงเฅฆ เคตเคฐ्เคทांเคš्เคฏा เคฎुเคฒीเคตเคฐ เคฎเคฐाเค ीเคค เคชाเคตเคธाเคตเคฐ เค•เคตिเคคा เคฒिเคนा."

  4. เคคुเคฒเคจाเคค्เคฎเค• (Comparative)

    • "เค…เคฎेเคฐिเค•ा เคต เคญाเคฐเคคाเคš्เคฏा เค†เคฐ्เคฅिเค• เคงोเคฐเคฃांเคšी เคคुเคฒเคจा เคคเค•्เคค्เคฏाเคš्เคฏा เคธ्เคตเคฐूเคชाเคค เค•เคฐा."

  5. เคธंเคตाเคฆी (Conversational)

    • "เคคुเคฎ्เคนी เคช्เคฐाเคšीเคจ เคฐोเคฎเคฎเคงीเคฒ เคŸूเคฐ เค—ाเคˆเคก เค†เคนाเคค เค…เคธे เคธเคฎเคœा. เคถเคนเคฐाเคคीเคฒ เคเค• เคฆिเคตเคธ เคธเคฎเคœाเคตूเคจ เคธांเค—ा."


เคช्เคฐॉเคฎ्เคช्เคŸ เค‡ंเคœिเคจिเค…เคฐिंเค—เคฎเคงीเคฒ เคธाเคฎाเคจ्เคฏ เคคंเคค्เคฐे

  • Zero-Shot Prompting: เค‰เคฆाเคนเคฐเคฃांเคถिเคตाเคฏ เค•ाเคฎ เคธोเคชเคตเคฃे.

  • Few-Shot Prompting: เค•ाเคนी เค‰เคฆाเคนเคฐเคฃे เคฆेเคŠเคจ เคฎाเคฐ्เค—เคฆเคฐ्เคถเคจ เค•เคฐเคฃे.

  • Chain-of-Thought Prompting: เคŸเคช्เคช्เคฏाเคŸเคช्เคช्เคฏाเคจे เคตिเคšाเคฐ เค•เคฐเคฃ्เคฏाเคธ เคธांเค—เคฃे.

  • Role-based Prompting: เคตिเคถिเคท्เคŸ เคญूเคฎिเค•ा เค˜्เคฏाเคฏเคฒा เคฒाเคตเคฃे.

  • Prompt Templates: เคชूเคฐ्เคตเคจिเคถ्เคšिเคค เคซॉเคฐเคฎॅเคŸ เคตाเคชเคฐเคฃे.


เค‰เคค्เคคเคฎ เคช्เคฐॉเคฎ्เคช्เคŸ्เคธเคธाเค ी เคŸिเคช्เคธ

  • เคธाเคงे เคธुเคฐू เค•เคฐा เคต เคนเคณूเคนเคณू เคธुเคงाเคฐเคฃा เค•เคฐा.

  • เคฎเคฐ्เคฏाเคฆा เคฆ्เคฏा (เค‰เคฆा. เฅงเฅฆเฅฆ เคถเคฌ्เคฆांเคค เค‰เคค्เคคเคฐ เคฆ्เคฏा).

  • เค…เคตเค˜เคก เค•ाเคฎ เค›ोเคŸे เคŸเคช्เคช्เคฏाเคค เคตिเคญाเคœिเคค เค•เคฐा.

  • เค†เค‰เคŸเคชुเคŸ เคคเคชाเคธा เค†เคฃि เคชुเคจ्เคนा เคช्เคฐเคฏเคค्เคจ เค•เคฐा.


เคช्เคฐॉเคฎ्เคช्เคŸिंเค—เคšी เค‰เคฆाเคนเคฐเคฃे

  • เคฎूเคฒเคญूเคค: "เคจ्เคฏूเคŸเคจเคšे เคจिเคฏเคฎ เคธเคฎเคœเคตा."

  • เคธुเคงाเคฐเคฒेเคฒे: "เคจ्เคฏूเคŸเคจเคšे เคคीเคจ เค—เคคीเคšे เคจिเคฏเคฎ เฅงเฅฆ เคตเคฐ्เคทांเคš्เคฏा เคฎुเคฒाเคฒा เคธเคฎเคœेเคฒ เค…เคถा เคธोเคช्เคฏा เคญाเคทेเคค เคธเคฎเคœเคตा."

  • เคซॉเคฐเคฎॅเคŸेเคก: "เคธौเคฐ เค‰เคฐ्เคœेเคšे เคซाเคฏเคฆे เคฌुเคฒेเคŸ เคชॉเค‡ंเคŸ्เคธเคฎเคง्เคฏे เคฒिเคนा."

  • เคญूเคฎिเค•ेเคธเคน: "เคคुเคฎ्เคนी เคถेเคซ เค†เคนाเคค. เคชाเคฒเค• เคต เคšเคฃ्เคฏांเคชाเคธूเคจ เคเค• เคนेเคฒ्เคฆी เคฐेเคธिเคชी เคฆ्เคฏा."


เคช्เคฐॉเคฎ्เคช्เคŸ เค‡ंเคœिเคจिเค…เคฐिंเค—เคฎเคงीเคฒ เค†เคต्เคนाเคจे

  • เค…เคธ्เคชเคท्เคŸ เคช्เคฐเคถ्เคจ = เค…เคจिเคถ्เคšिเคค เค‰เคค्เคคเคฐे

  • เคšुเค•ीเคšी เคฎाเคนिเคคी (Hallucinations)

  • เคŸोเค•เคจ เคฎเคฐ्เคฏाเคฆा

  • เคชเค•्เคทเคชाเคค เคต เคจैเคคिเค•เคคा

  • เค‰เคค्เคคเคฐांเคฎเคง्เคฏे เคธाเคคเคค्เคฏ เคจเคธเคฃे


เคช्เคฐॉเคฎ्เคช्เคŸ เค‡ंเคœिเคจिเค…เคฐिंเค—เคšा เคตाเคชเคฐ

  • เคธॉเคซ्เคŸเคตेเค…เคฐ เคตिเค•ाเคธ: เค•ोเคก เคœเคจเคฐेเคถเคจ, เคกिเคฌเค—िंเค—

  • เคฎाเคฐ्เค•ेเคŸिंเค—: เคœाเคนिเคฐाเคคी, เคˆเคฎेเคฒ, เค•ंเคŸेंเคŸ เค†เคฏเคกिเคฏा

  • เคถिเค•्เคทเคฃ: เคŸ्เคฏूเคถเคจ, เคฒेเคธเคจ เคช्เคฒॅเคจिंเค—

  • เคธंเคถोเคงเคจ: เคชेเคชเคฐ เคธाเคฐांเคถ, เค—ृเคนिเคคเค•े เคคเคฏाเคฐ เค•เคฐเคฃे

  • เค•เคฒा: เค•เคตिเคคा, เค•เคฅा, เค†เคฏเคกिเคฏा


เคญเคตिเคท्เคฏाเคคीเคฒ เคช्เคฐॉเคฎ्เคช्เคŸ เค‡ंเคœिเคจिเค…เคฐिंเค—

  • เคช्เคฐॉเคฎ्เคช्เคŸ เคช्เคฐोเค—्เคฐॅเคฎिंเค— เคญाเคทा

  • เคฎเคฒ्เคŸी-เคฎोเคกเคฒ เคช्เคฐॉเคฎ्เคช्เคŸिंเค— (เคŸेเค•्เคธ्เคŸ + เค‡เคฎेเคœ + เค‘เคกिเค“)

  • เคธ्เคตเคฏंเคšเคฒिเคค เคช्เคฐॉเคฎ्เคช्เคŸ เค‘เคช्เคŸिเคฎाเคฏเคेเคถเคจ

  • เค…ॅเคช्เคธ เคต เคตเคฐ्เค•เคซ्เคฒोเคฎเคง्เคฏे เคเคฎ्เคฌेเคกेเคก เคช्เคฐॉเคฎ्เคช्เคŸ्เคธ


เคจिเคท्เค•เคฐ्เคท

เคช्เคฐॉเคฎ्เคช्เคŸ เค‡ंเคœिเคจिเค…เคฐिंเค— เคนे เคฎाเคจเคตी เคนेเคคू เคต เคฏंเคค्เคฐाเคšे เค‰เคค्เคคเคฐ เคฏांเคš्เคฏाเคคीเคฒ เคฆुเคตा เค†เคนे.
เคนे เค•ौเคถเคฒ्เคฏ AI เคšी เค–เคฐी เค•्เคทเคฎเคคा เค‰เค˜เคกเคคे เคต เคตाเคชเคฐเค•เคฐ्เคค्เคฏाเคฒा เคจेเคฎเค•े เคนเคตे เคคเคธे เคชเคฐिเคฃाเคฎ เคฎिเคณเคตूเคจ เคฆेเคคे.
เคฎूเคฒเคญूเคค เคคเคค्เคค्เคตे เคธเคฎเคœूเคจ เค˜ेเคŠเคจ, เคตिเคตिเคง เคคंเคค्เคฐे เคตाเคชเคฐूเคจ เคต เคธเคฐाเคต เค•เคฐूเคจ เค•ोเคฃเคคाเคนी เคต्เคฏเค•्เคคी เคฏा เค†เคงुเคจिเค• เค•ौเคถเคฒ्เคฏाเคค เคช्เคฐाเคตीเคฃ्เคฏ เคฎिเคณเคตू เคถเค•เคคो.


๐Ÿ‘‰ เค‡ंเค—्เคฐเคœी เค†เคตृเคค्เคคीเคธाเค ी เคฒिंเค•:  Read Prompt Engineering in English
✍️ เคฒेเค–เค•: เค…เคœเคฏ เค•े. เคฌเคฐ्เคตे


Monday, August 11

Agentic AI Mastery: From Zero to Pro — The Brain of the Agent (Module- 3)

 

๐Ÿ“Œ Module 3: The Brain of the Agent — LLM Fundamentals

1. Theory

Large Language Models (LLMs) are at the heart of most modern AI agents.
They process text, reason about it, and generate responses that guide the agent’s actions. 
Kirk Borne ุนู„ู‰ X: "#infographic List of large Language Models for ...

 

Key Concepts

  • Tokenization → Breaking text into smaller units the model can understand.
  • Embeddings → Vector representations of text for semantic understanding.
  • Context Window → The limit on how much information the LLM can “see” at once.
  • Prompt Engineering → Crafting instructions to get desired outputs.

LLM Types

  • Local LLMs → Run entirely on your machine (e.g., LLaMA, Mistral)
  • Cloud-based LLMs → Accessed via APIs (e.g., OpenAI GPT-4, Anthropic Claude)

2. Step-by-Step Windows Setup (For This Module)

  1. Install Transformers Library

2.  pip install transformers

3.  pip install sentence-transformers

  1. Download a Small Local Model (for quick testing)

5.  from transformers import pipeline

6.  gen = pipeline("text-generation", model="distilgpt2")

7.  print(gen("Agentic AI is", max_length=20))

  1. Set Up an Embeddings Model

9.  from sentence_transformers import SentenceTransformer

10.model = SentenceTransformer('all-MiniLM-L6-v2')

11.embeddings = model.encode("Agentic AI learns and acts")

12.print(embeddings[:5])


3. Examples

Example 1 — Few-Shot Prompt for Classification

from transformers import pipeline

classifier = pipeline("zero-shot-classification", model="facebook/bart-large-mnli")

print(classifier("Build an agent that schedules meetings", candidate_labels=["Productivity", "Gaming", "Education"]))

Example 2 — Summarizing a News Article

summarizer = pipeline("summarization", model="facebook/bart-large-cnn")

print(summarizer("Artificial Intelligence is transforming industries...", max_length=40, min_length=10))

Example 3 — Semantic Search Using Embeddings

from sklearn.metrics.pairwise import cosine_similarity

docs = ["AI helps businesses", "Cooking pasta", "Agentic AI automates tasks"]

query = "automation in AI"

doc_embeddings = [model.encode(doc) for doc in docs]

query_embedding = model.encode(query)

scores = cosine_similarity([query_embedding], doc_embeddings)

print(scores)


4. Exercises

  1. Create a prompt that classifies user queries into “Tech” or “Non-Tech”.
  2. Build a summarizer for PDF documents.
  3. Use embeddings to find the most relevant FAQ answer to a user’s question.

5. Best Practices

  • Always test with small models before switching to expensive ones.
  • Optimize prompts for clarity and structure.

6. Common Mistakes

  • Sending too much data beyond the context window → truncated outputs.
  • Using embeddings from one model with another model for similarity search.

7. Quiz

  1. What is the purpose of embeddings in LLMs?
  2. What’s the difference between few-shot and zero-shot classification?
  3. Why is the context window important?

Agentic AI Mastery: From Zero to Pro — A Complete Guide (Module-2)

๐Ÿ“Œ Module 2: Your AI Workbench — Setting Up on Windows

1. Theory

A well-configured environment is the foundation for building and running Agentic AI applications efficiently.
On Windows, this means:

  • Installing the right tools (Python, Git, IDEs)
  • Managing virtual environments
  • Installing dependencies
  • Setting up local or cloud-based LLMs

A proper setup ensures reproducibility — you and others can run the same code with minimal issues.


Why Windows Setup Matters for AI Development

  • Many developers in enterprises use Windows by default.
  • With WSL2 or native Python, you can still run modern AI frameworks.
  • Windows allows both local LLM execution and cloud API integration.

2. Step-by-Step Windows Setup (For This Module)

  1. Install Python 3.10+
  2. Install Git
  3. Install VS Code
  4. Install Ollama for Local LLMs

o   ollama run llama2

  1. Create Virtual Environment

6.  python -m venv agentic_env

7.  .\agentic_env\Scripts\activate

  1. Install Libraries

9.  pip install langchain openai requests wikipedia python-dotenv


3. Examples

Example 1 — Running a Local LLM

  • Run:

·       ollama run llama2

  • Type:

·       What is Agentic AI?

Example 2 — Testing LangChain Installation

from langchain.prompts import PromptTemplate

template = PromptTemplate(input_variables=["name"], template="Hello {name}, welcome to Agentic AI!")

print(template.format(name="Ajay"))

Example 3 — Using Hugging Face Transformers Locally

from transformers import pipeline

qa = pipeline("question-answering", model="distilbert-base-uncased-distilled-squad")

print(qa(question="What is AI?", context="AI stands for Artificial Intelligence."))


4. Exercises

  1. Install a different local model in Ollama.
  2. Create a Python script that checks if all dependencies are installed.
  3. Set up a VS Code workspace for an Agentic AI project.

5. Best Practices

  • Keep your virtual environment per project.
  • Use requirements.txt to track dependencies.

6. Common Mistakes

  • Forgetting to activate the venv before installing packages.
  • Using system Python instead of project-specific venv.

7. Quiz

  1. Which command activates a virtual environment in PowerShell?
  2. Name two benefits of using Ollama locally.
  3. Why should you keep a requirements.txt file?



๐Ÿง  Tutorial: “Master SQL Using Perplexity AI — From Beginner to Pro” by Ajay Architect

⏱ Tutorial Duration: 15–30 minutes approximate  ๐Ÿ’ก Goal:  Teach how to use AI tools like Perplexity, ChatGPT or Gemini  to write, optimi...