Generative and Agentic AI Masterclass - Internship Assured

Exercise 1: Text Classifier using Embeddings

Objective:

Build a basic neural network to classify movie reviews (positive/negative) using word embeddings.

Concepts Used:

Tokenization, padding, Keras Tokenizer, Embedding layer, binary classification.

Steps:

• Preprocessing text (lowercasing, tokenization, padding)
• Creating word embeddings with Keras
• Building a Sequential model in Keras
• Training and evaluating a basic classifier on a small dataset like IMDB or a CSV-based custom dataset

Exercise 2: Character-Level Text Generator with LSTM

Objective:

Generate new names, words, or short poems using a character-level LSTM network.

Concepts Used:

Sequence modeling, one-hot encoding, LSTM architecture, text generation.

Steps:

• Preparing character sequences from a sample corpus (e.g., names or poems)
• Building and training a simple LSTM-based model
• Using sampling techniques to generate new text from learned character patterns

Exercise 3: Fine-Tune BERT & Generate Text with GPT

Objective:

Explore transfer learning by fine-tuning a BERT model for classification and using GPT for creative text generation.

Concepts Used:

Pretraining vs fine-tuning, Transformers, Prompt engineering, Hugging Face Transformers API.

Part A – BERT:

• Load a pretrained BERT model using Hugging Face
• Fine-tune it on a sentiment dataset or text classification dataset
• Evaluate predictions

Part B – GPT:

• Use OpenAI's GPT or Hugging Face GPT to:
• Generate a blog intro
• Summarize an article
• Create a story based on a few-shot prompt

Exercise 1: FAQ-Based Document Chatbot

Objective:

Create a chatbot that can answer questions from an uploaded FAQ document or manual using semantic similarity.

Concepts Used:

Document parsing, sentence embeddings (e.g., Sentence Transformers), cosine similarity, Streamlit interface.

Steps:

• Uploading a .txt or .pdf file
• Breaking the document into chunks
• Converting chunks into embeddings
• Matching user queries to the most relevant chunk using cosine similarity
• Displaying the response using a basic Streamlit chatbot interface

Exercise 2: Database-Driven Attendance Bot

Objective:

Build a chatbot that parses user queries like "Who was present on May 5?" and answers using a connected SQL database.

Concepts Used:

Natural language to SQL mapping, DB integration (MySQL/PostgreSQL), Flask API, query handling logic.

Steps:

• Create a sample attendance table in MySQL/PostgreSQL
• Map user-friendly queries to SQL queries (hardcoded or via pattern matching)
• Fetch answers from the DB
• Build a simple Flask API to return the results

Exercise 3: Quotation Generator Bot with PDF Output

Objective:

Create a chatbot interface that takes user input through a form and generates a formatted quotation as a downloadable PDF.

Concepts Used:

Form handling, templating with Jinja2, PDF generation with ReportLab or python-docx, Streamlit/Gradio frontend.

Steps:

• Input form for customer name, items, prices, taxes
• Template rendering with Jinja2
• Generate a styled PDF quotation
• Build API with Flask and frontend with Streamlit or Gradio for user interaction

Exercise 1: Technical Q&A Bot from Uploaded PDFs

Objective:

Build a chatbot that can answer technical or academic questions from uploaded multi-page PDFs (e.g., research papers, manuals).

Concepts Used:

PDF parsing (PyMuPDF or pdfminer), text chunking, sentence embeddings (e.g., Sentence Transformers), vector similarity search, Streamlit interface.

Steps:

• Upload and parse PDF documents
• Break text into chunks with overlap
• Create embeddings and store in-memory using FAISS or Chroma
• Accept user queries and return relevant matched content
• Deploy the bot using Streamlit

Exercise 2: Image Generator with DALL·E / Stable Diffusion

Objective:

Build an application that generates creative images from text prompts using DALL·E or open-source diffusion models.

Concepts Used:

Prompt engineering, text-to-image API (OpenAI or HuggingFace), Gradio interface, prompt variation logic.

Steps:

• Input: Text prompt from user
• Generate image using DALL·E API or local Stable Diffusion model
• Support for prompt templates like "A futuristic city in the style of..."
• Interface built with Gradio for interactive experience

Exercise 3: RAG-Based Knowledge Assistant

Objective:

Build a Retrieval-Augmented Generation (RAG) chatbot that answers questions using a document knowledge base + LLMs.

Concepts Used:

Embeddings, vector databases (FAISS, Pinecone, or Chroma), document retrieval, LLM prompting with retrieved context.

Steps:

• Upload multiple knowledge documents
• Chunk, embed, and store in vector store
• User query triggers retrieval of top-k chunks
• Retrieved text is sent as context to LLM (e.g., GPT-4)
• Return and display final generated answer

Exercise 1: Build a Multi-Tool AI Agent with Flowise

Objective:

Create a visual AI agent using Flowise that performs multiple tasks such as content generation, question answering, and creative writing.

Concepts Used:

LangChain components via Flowise, tool integration, agent chaining, memory components, API orchestration.

Steps:

• Set up Flowise and create a new agent
• Add tools: LLM (OpenAI), Prompt Template, Document Loader, Output Parser
• Build 2–3 use cases like: Content writing assistant (e.g., blog title + body), Product Q&A from knowledge base
• Deploy the agent using Flowise frontend

Exercise 2: Function-Calling Agent with Calculator & Python Code Interpreter

Objective:

Build a custom agent that dynamically calls specific functions (e.g., calculator, Python executor) based on user query.

Concepts Used:

Function calling in OpenAI GPT, JSON schema, code execution from Python environment, memory-based routing.

Steps:

• Define function schema for: calculator, Python code execution
• Configure agent to parse user input and choose the right function
• Examples: "What is 27% of 3800?", "Write Python code to find prime numbers from 1 to 100"
• Show result from appropriate function and return final output

Exercise 3: Lead Generation AI Agent with Internet Search (Flowise + LangChain)

Objective:

Create a lead generation agent that performs basic research on a person or business and drafts a custom outreach email.

Concepts Used:

LLMs, memory, function calling, search tools, prompt chaining, text summarisation.

Steps:

• Use a research tool plugin (DuckDuckGo, SerpAPI, or static dummy search for demo)
• Prompt agent to search for a person/business
• Extract useful data (name, role, company, recent work)
• Generate a personalized email using GPT-4
• Wrap in Flowise interface for input/output

Exercise 1: Set Up and Run a Local LLaMA 3.1 Agent

Objective:

Install and configure a local instance of the LLaMA 3.1 model and build a simple chatbot using it.

Concepts Used:

Open-source LLMs, local model deployment, inference APIs, resource management.

Steps:

• Download and install Ollama or relevant LLaMA runtime
• Load LLaMA 3.1 model locally
• Build a simple chat interface to interact with the model
• Test with example queries for knowledge retrieval or casual chat

Exercise 2: Build a Privacy-Focused RAG Chatbot with Flowise + Ollama

Objective:

Combine local LLM with a private knowledge base for document Q&A without sending data to the cloud.

Concepts Used:

Retrieval-Augmented Generation, vector databases, local embeddings, privacy in AI.

Steps:

• Prepare a private document dataset (PDFs, docs)
• Create embeddings locally and set up a vector store
• Connect local LLaMA model with the vector store via Flowise
• Build chatbot interface that answers queries from local docs only

Exercise 3: Ethical AI Scenario Analysis & Mitigation

Objective:

Analyze a given scenario involving AI bias or security threats, then propose ethical mitigation strategies.

Concepts Used:

AI ethics, bias in datasets, prompt injection, data poisoning, IP concerns.

Steps:

• Given 2-3 real-world scenarios (e.g., biased hiring AI, prompt injection attack)
• Identify the ethical challenges and risks
• Suggest practical solutions or safeguards (e.g., data auditing, adversarial testing)
• Present findings and recommendations in a report or presentation format