import { GoogleGenAI } from "@google/genai";
import { config } from "dotenv";
 
// Read your .env file where your API key is hidden
config();
 
const ai = new GoogleGenAI({
  apiKey: process.env.GEMINI_API_KEY,
});

model: "gemini-2.5-flash";

{
  role: "user",
  parts: [{ text: "Explain closures." }]
}

contents: [
  {
    role: "user",
    parts: [{ text: "What is a closure?" }],
  },
  {
    role: "model",
    parts: [
      {
        text: "A closure is a function that remembers variables from its outer scope...",
      },
    ],
  },
  {
    role: "user",
    parts: [{ text: "Can you give me an example?" }],
  },
];

thinkingConfig: {
  thinkingBudget: 1024,
}

const response = await ai.models.generateContent({
  model: "gemini-2.5-flash",
 
  config: {
    // Tell the AI how to behave
    systemInstruction: "You are an expert JavaScript teacher.",
 
    // Optional reasoning
    thinkingConfig: {
      includeThoughts: true, // add thought summary
      thinkingBudget: 1024,
    },
  },
 
  contents: [
    {
      role: "user",
      parts: [
        {
          text: "Explain JavaScript closures.",
        },
      ],
    },
  ],
});
 
console.log(response.text);
console.log(response.candidates[0].content); // for thought summary

config: {
  temperature: 1,
}

config: {
  maxOutputTokens: 800,
}

import { GoogleGenAI } from "@google/genai";
import { config } from "dotenv";
 
// Read .env file
config();
 
const GEMINI_API_KEY = process.env.GEMINI_API_KEY;
const MODEL = "gemini-2.5-flash";
 
// Conversation history array
const CONTEXT = [];
 
const client = new GoogleGenAI({
  apiKey: GEMINI_API_KEY,
});
 
async function aiAnswer(prompt) {
  // 1. Save the user's message to our history
  CONTEXT.push({
    role: "user",
    parts: [{ text: prompt }],
  });
 
  // 2. Send the entire history to Gemini
  const response = await client.models.generateContent({
    model: MODEL,
    config: {
      systemInstruction: "Keep answers short, technical, and simple.",
      temperature: 0.3, // Low temperature keeps code answers accurate and stable
    },
    contents: CONTEXT,
  });
 
  console.log("\nAI:", response.text);
 
  // 3. Save the AI's response to our history so it remembers next time
  CONTEXT.push({
    role: "model",
    parts: [{ text: response.text }],
  });
 
  process.stdout.write("\nYou: ");
}
 
// Start the command line interface
process.stdout.write("You: ");
 
process.stdin.on("data", async (data) => {
  const question = data.toString().trim();
 
  if (question.toLowerCase() === "exit") {
    process.exit(0);
  }
 
  try {
    await aiAnswer(question);
  } catch (err) {
    console.error("Oops, something went wrong:", err);
  }
});

Input Text
   │
   ▼
Tokenizer → Tokens (numbers)
   │
   ▼
Transformer Model → Hidden state vector per position
   │
   ▼
Projection + Softmax → Probability distribution over all possible next tokens
   │
   ▼
Sample next token (temperature affects this)
   │
   ▼
Append to sequence
   │
   ▼
Repeat until stop token or max output length

"What is the capital of France?"
   → tokenizer → [What, is, the, capital, of, France, ?]
   → model → probability distribution
       "Paris": 0.47
       "The": 0.12
       "Lyon": 0.08
       ...
   → sample → "Paris" (probably)
   → append → "Paris"
   → next iteration: input now "...France? Paris"
   → eventually generates "."
   → stop token → end

import { GoogleGenAI } from "@google/genai";
 
const client = new GoogleGenAI({
  apiKey: process.env.GEMINI_API_KEY,
});
 
const response = await client.models.embedContent({
  model: "gemini-embedding-2", // gemini-embedding-001
  contents: "dog",
});
 
console.log(response.embeddings);
console.log(
  "Vector Length (dimensions):",
  response.embeddings[0].values.length,
);

// Dot Product Similarity
 
import { GoogleGenAI } from "@google/genai";
import { config } from "dotenv";
 
config();
 
const client = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
const MODEL = "gemini-embedding-001";
 
// Helper function to calculate Dot Similarity
function dotProduct(vecA, vecB) {
  return vecA.reduce((sum, value, i) => sum + value * vecB[i], 0);
}
 
async function findSimilarity(inputs, query) {
  // Generate embeddings for all inputs + query
  const response = await client.models.embedContent({
    model: MODEL,
    contents: [...inputs, query],
  });
 
  const embeddings = response.embeddings.map((e) => e.values);
 
  // Last embedding belongs to the query
  const queryEmbedding = embeddings.pop();
 
  // Calculate dot product similarity using the extracted function
  return inputs.map((input, index) => {
    const similarity = dotProduct(embeddings[index], queryEmbedding);
    return {
      input,
      similarity,
    };
  });
}
 
const data = [
  "Lion",
  "Tiger",
  "Elephant",
  "Dog",
  "Cat",
  "Mango",
  "Apple",
  "Banana",
  "Orange",
  "Grapes",
  "Parrot",
  "Peacock",
  "Eagle",
  "Sparrow",
  "Pigeon",
  "Horse",
  "Watermelon",
  "Guava",
  "Crow",
  "Deer",
];
 
const result = await findSimilarity(data, "animal");
 
// Sort by highest similarity so you can easily see the best matches
result.sort((a, b) => b.similarity - a.similarity);
 
console.log("\n--- Similarity Results ---");
result.forEach((item) =>
  console.log(`${item.input}: ${item.similarity.toFixed(4)}`),
);

// Cosine Similarity
 
import { GoogleGenAI } from "@google/genai";
import { config } from "dotenv";
 
config();
 
const client = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
const MODEL = "gemini-embedding-2";
 
// Helper function to calculate Cosine Similarity
function cosineSimilarity(vecA, vecB) {
  const dotProduct = vecA.reduce((sum, val, i) => sum + val * vecB[i], 0);
  const normA = Math.sqrt(vecA.reduce((sum, val) => sum + val * val, 0));
  const normB = Math.sqrt(vecB.reduce((sum, val) => sum + val * val, 0));
  return dotProduct / (normA * normB);
}
 
async function findSimilarity(inputs, query) {
  console.log("Generating embeddings...");
 
  // 1. Embed the target inputs as RETRIEVAL_DOCUMENT
  const inputPromises = inputs.map((input) =>
    client.models.embedContent({
      model: MODEL,
      contents: input,
      config: { taskType: "RETRIEVAL_DOCUMENT" },
    }),
  );
 
  // 2. Embed the query as RETRIEVAL_QUERY
  const queryPromise = client.models.embedContent({
    model: MODEL,
    contents: query,
    config: { taskType: "RETRIEVAL_QUERY" },
  });
 
  // Resolve all API calls in parallel
  const [queryResponse, ...inputResponses] = await Promise.all([
    queryPromise,
    ...inputPromises,
  ]);
 
  const queryEmbedding = queryResponse.embeddings[0].values;
  const inputEmbeddings = inputResponses.map((r) => r.embeddings[0].values);
 
  // 3. Calculate similarity using Cosine Similarity
  return inputs.map((input, index) => {
    const similarity = cosineSimilarity(inputEmbeddings[index], queryEmbedding);
    return {
      input,
      similarity,
    };
  });
}
 
const data = [
  "Lion",
  "Tiger",
  "Elephant",
  "Dog",
  "Cat",
  "Mango",
  "Apple",
  "Banana",
  "Orange",
  "Grapes",
  "Parrot",
  "Peacock",
  "Eagle",
  "Sparrow",
  "Pigeon",
  "Horse",
  "Watermelon",
  "Guava",
  "Crow",
  "Deer",
];
 
const result = await findSimilarity(data, "animal");
 
// Sort by highest similarity so you can easily see the best matches
result.sort((a, b) => b.similarity - a.similarity);
console.log("\n--- Similarity Results ---");
result.forEach((item) =>
  console.log(`${item.input}: ${item.similarity.toFixed(4)}`),
);

{
  "vector": [...],
  "title": "Node.js Worker Threads",
  "author": "John",
  "category": "Programming"
}

import { GoogleGenAI } from "@google/genai";
import { CloudClient } from "chromadb";
import { config } from "dotenv";
 
config();
 
const { CHROMA_API_KEY, CHROMA_TENANT, CHROMA_DATABASE, GEMINI_API_KEY } =
  process.env;
 
const MODEL = "gemini-embedding-001";
 
const vectorDbClient = new CloudClient({
  apiKey: CHROMA_API_KEY,
  tenant: CHROMA_TENANT,
  database: CHROMA_DATABASE,
});
 
const googleAI = new GoogleGenAI({ apiKey: GEMINI_API_KEY });
 
async function generateEmbeddings(textArray) {
  const response = await googleAI.models.embedContent({
    model: MODEL,
    contents: textArray,
  });
  return response.embeddings.map((e) => e.values);
}
 
async function addItems(collectionName, items) {
  const collection = await vectorDbClient.getOrCreateCollection({
    name: collectionName,
  });
  const embeddings = await generateEmbeddings(items);
  const ids = items.map((_, i) => String(i + 1));
  await collection.add({ ids, documents: items, embeddings });
  console.log(`Added ${items.length} items to "${collectionName}"`);
}
 
async function getSimilar(collectionName, query, nResults = 3) {
  const collection = await vectorDbClient.getCollection({
    name: collectionName,
  });
  const [embedding] = await generateEmbeddings([query]);
  const result = await collection.query({
    queryEmbeddings: [embedding],
    nResults,
  });
  console.log(result);
  return result;
}
 
// --- usage ---
const collectionName = "test";
const items = ["apple", "banana", "grape", "blue", "red", "green"];
 
async function run() {
  // await addItems(collectionName, items);  // uncomment to add once
  await getSimilar(collectionName, "get me a green color");
}
 
run();

import { GoogleGenAI } from "@google/genai";
import { CloudClient } from "chromadb";
import { config } from "dotenv";
 
config();
 
// --- Clients ---
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
const vectorDb = new CloudClient({
  apiKey: process.env.CHROMA_API_KEY,
  tenant: process.env.CHROMA_TENANT,
  database: process.env.CHROMA_DATABASE,
});
 
// Models we'll use
const EMBED_MODEL = "gemini-embedding-001"; // turns text → numbers
const CHAT_MODEL = "gemini-2.5-flash"; // generates answers
 
// --- Helper: generate embeddings for multiple texts ---
async function getEmbeddings(texts) {
  const response = await ai.models.embedContent({
    model: EMBED_MODEL,
    contents: texts, // can be an array of strings
  });
 
  // return the list of number arrays
  return response.embeddings.map((e) => e.values);
}
 
// --- Store documents in the vector database ---
async function storeDocs(collectionName, documents) {
  // Create a collection (like a table) if it doesn't exist
  const collection = await vectorDb.getOrCreateCollection({
    name: collectionName,
  });
 
  // Make embeddings for the documents
  const embeddings = await getEmbeddings(documents);
  const ids = documents.map((_, i) => String(i)); // simple IDs: "0", "1", "2"
 
  // Add documents + embeddings to ChromaDB
  await collection.add({
    ids,
    documents,
    embeddings,
  });
 
  console.log(`Stored ${documents.length} documents in "${collectionName}".`);
}
 
// --- Retrieve relevant documents for a question ---
async function findRelevantDocs(collectionName, question, topN = 2) {
  const collection = await vectorDb.getCollection({ name: collectionName });
  const [questionEmbedding] = await getEmbeddings([question]);
 
  // Ask ChromaDB: "Which documents are closest to this question embedding?"
  const result = await collection.query({
    queryEmbeddings: [questionEmbedding],
    nResults: topN,
  });
 
  // result.documents[0] contains the text of the matched documents
  return result.documents[0] ?? [];
}
 
// --- Ask the LLM with retrieved context ---
async function askAIWithContext(question, contextDocs) {
  // Combine the documents into one string
  const context = contextDocs
    .map((doc, i) => `[Document ${i + 1}]\n${doc}`)
    .join("\n\n");
 
  // Build a prompt that tells the AI to use only the context
  const prompt = `You are a helpful assistant.
Use ONLY the documents below to answer the question.
If the answer isn't there, say "I don't know."
 
${context}
 
Question: ${question}
Answer:`;
 
  const response = await ai.models.generateContent({
    model: CHAT_MODEL,
    config: {
      systemInstruction: "Answer based strictly on the provided documents.",
      temperature: 0, // fact‑based task, not creative
    },
    contents: [{ role: "user", parts: [{ text: prompt }] }],
  });
 
  return response.text;
}
 
// --- Put it all together ---
async function ragPipeline() {
  const collectionName = "company-info";
 
  // Our "knowledge base" – pretend these are pages from a handbook
  const docs = [
    "Employees get 20 paid vacation days per year.",
    "The office gym is open from 6 AM to 10 PM.",
    "Remote work is allowed on Fridays with manager approval.",
  ];
 
  // Store the documents (run this only once normally)
  await storeDocs(collectionName, docs);
 
  // Ask a question
  const question = "What is the company vacation policy?";
  console.log(`\n❓ Question: ${question}`);
 
  // Retrieve the most relevant document
  const relevantDocs = await findRelevantDocs(collectionName, question, 1);
  console.log("📄 Found this relevant info:", relevantDocs);
 
  // Let the AI answer using that info
  const answer = await askAIWithContext(question, relevantDocs);
  console.log(`🤖 Answer: ${answer}`);
}
 
ragPipeline();

import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
import { config } from "dotenv";
 
config();
process.env.GOOGLE_API_KEY = process.env.GEMINI_API_KEY;
 
const llm = new ChatGoogleGenerativeAI({
  model: "gemini-2.5-flash",
  temperature: 0,
});
 
async function chat() {
  const response = await llm.invoke("Tell me 5 fruit names");
  console.log(response);
}
chat();

const responses = await llm.batch([
  "Top 5 countries",
  "Top footballers in the world",
]);
console.log(responses);

const stream = await llm.stream("Top footballers in the world");
for await (const chunk of stream) {
  console.log(chunk);
}

import { ChatPromptTemplate } from "@langchain/core/prompts";
 
const prompt = ChatPromptTemplate.fromTemplate(
  "Tell me about {topic} in {words} words.",
);
const formatted = await prompt.formatMessages({
  topic: "JavaScript",
  words: 50,
});
const response = await llm.invoke(formatted);

const prompt = ChatPromptTemplate.fromMessages([
  ["system", "Explain the topic within 100 words"],
  ["human", "Tell me about {topic} with examples"],
]);

import { CommaSeparatedListOutputParser } from "@langchain/core/output_parsers";
 
const chain = prompt.pipe(llm).pipe(new CommaSeparatedListOutputParser());
const result = await chain.invoke({
  topic: "programming languages",
  words: 30,
});
// result is an array: ["Python", "JavaScript", "Rust", ...]

import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
import { Chroma } from "@langchain/community/vectorstores/chroma";
import { GoogleGenerativeAIEmbeddings } from "@langchain/google-genai";
import { StringOutputParser } from "@langchain/core/output_parsers";
import { ChatPromptTemplate } from "@langchain/core/prompts";
 
// 1. Set up embeddings and vector store
const embeddings = new GoogleGenerativeAIEmbeddings({
  model: "gemini-embedding-001",
});
const vectorStore = await Chroma.fromTexts(
  [
    "Employees get 20 paid vacation days per year.",
    "The office gym is open from 6 AM to 10 PM.",
    "Remote work is allowed on Fridays with manager approval.",
  ],
  { ids: ["doc1", "doc2", "doc3"] },
  embeddings,
  { collectionName: "company-info" },
);
 
// 2. Create a retriever
const retriever = vectorStore.asRetriever(1); // return top 1
 
// 3. Build a RAG chain
const llm = new ChatGoogleGenerativeAI({ model: "gemini-2.5-flash" });
const prompt = ChatPromptTemplate.fromMessages([
  ["system", "Answer based ONLY on the following context:\n\n{context}"],
  ["human", "{question}"],
]);
 
const chain = prompt.pipe(llm).pipe(new StringOutputParser());
 
// 4. Query with retrieval
const question = "What is the vacation policy?";
const docs = await retriever.getRelevantDocuments(question);
const context = docs.map((doc) => doc.pageContent).join("\n");
const answer = await chain.invoke({ question, context });
console.log(answer);

### 1. ROLE
You are a [specific job/domain], responsible for [specific responsibility].
 
This shapes vocabulary, tone, and scope. Base it on actual domain roles,
not flattery. "You are a billing support assistant" works.
"You are a world-class genius" does nothing.
 
### 2. TASK
Your task is to [single, unambiguous action verb + object].
 
One job only. Not "help the user" — "classify the complaint."
Not "analyze this text" — "extract all mentioned dates in YYYY-MM-DD format."
 
### 3. CONSTRAINTS
You must choose ONLY from the following: [A, B, C].
Do not invent new categories or combine categories.
 
If the task is extraction, constrain the output schema.
If classification, constrain the label set.
If generation, constrain length, format, or style
 
### 4. OUTPUT FORMAT
Respond with [exact format: one word / JSON schema / markdown table / etc].
No preamble, no explanation, no punctuation beyond what's specified.
 
For structured data, provide the exact JSON schema, not a description.
For free text, specify exactly what delimiters or markers to use (or omit).
 
### 5. FEW-SHOT EXAMPLES
Input: "..." → Output: "..."
Input: "..." → Output: "..."
 
2-3 well-chosen examples usually outperform a paragraph of description.
Choose examples that demonstrate edge cases, not just the happy path.
Include one example of the fallback case if possible.
 
### 6. FALLBACK
If the input doesn't clearly match any category above, respond with "Other"
[or: ask one clarifying question / return null / respond with empty JSON].
 
This is the safety net. Without it, ambiguous or out-of-scope input gets
force-fit into the nearest wrong bucket.
 
### 7. CONFIDENCE / ESCALATION
If you are not reasonably confident which category applies,
respond with "Needs Review" instead of guessing.
 
This is different from Fallback:
- Fallback handles inputs that fit NO category ("My girlfriend left me")
- Escalation handles inputs that fit MULTIPLE categories equally well
  ("My laptop screen flickers and I just bought it" — Technical or Return?)
 
Missing this distinction is how you get silently wrong classifications
instead of obviously wrong ones. The silent errors are far worse,
because nobody notices them.

### 1. ROLE
You are a support assistant at a consumer electronics company,
responsible for the initial triage of user complaints.
 
### 2. TASK
Classify the user's complaint into a single category.
 
### 3. CONSTRAINTS
Choose ONLY from this list: Billing, Technical, Return.
Do not invent new categories or combine them.
 
### 4. OUTPUT FORMAT
Respond with exactly ONE WORD. No punctuation. No explanation.
No leading or trailing whitespace.
 
### 5. FEW-SHOT EXAMPLES
Input: "I want a refund for my phone" → Return
Input: "My screen won't turn on" → Technical
Input: "I was charged twice for one order" → Billing
Input: "Do you sell phone cases?" → Other
Input: "The keyboard stopped working and I want my money back" -> Needs Review
 
### 6. FALLBACK
If the input is unrelated to Billing, Technical, or Return,
respond with: Other
 
### 7. CONFIDENCE / ESCALATION
If the input could reasonably fit two categories and you cannot
determine which is more appropriate, respond with: Needs Review
 
User's complaint: My new laptop has a flickering screen. I want a replacement.

### ROLE
You are a data extraction specialist. You pull structured
information out of text.
 
### TASK
Find all dates mentioned in the text. For each date,
describe what event happened on that date.
 
### CONSTRAINTS
- Only extract dates that are clearly stated. Do not guess dates.
- Write all dates as YYYY-MM-DD.
- If a date is incomplete (like "March 2024"), use the first day
  of that month.
 
### OUTPUT FORMAT
Return a JSON array. Each item must have "date" and "event" fields.
Example: [{"date": "2024-03-15", "event": "project deadline"}]
Return ONLY the JSON. No other text.
 
### FEW-SHOT EXAMPLES
Text: "The conference is on January 10th, 2025. Registration
closes December 1st."
Output: [
		{"date": "2025-01-10", "event": "conference"},
		{"date": "2024-12-01", "event": "registration closes"},
]
 
Text: "We met last Tuesday to discuss the Q2 roadmap."
Output: []
 
### FALLBACK
If there are no dates, return an empty JSON array: []
 
### CONFIDENCE / ESCALATION
If a date is unclear (like "next Friday" with no reference point),
leave it out. Only return dates you are sure about.

### ROLE
You are a customer support agent for Acme Corp.
You answer questions using only the documents provided to you.
 
### TASK
Answer the user's question based only on the context documents.
 
### CONSTRAINTS
- Only use information from the documents below.
- Do not use anything you learned during training.
- If two documents disagree, point out the conflict.
- For every fact you use, cite which document it came from.
  Use [Doc 1], [Doc 2], etc.
 
### OUTPUT FORMAT
Write your answer in plain paragraphs.
At the end, add a "Sources:" section listing the documents you used.
If you cannot answer from the documents, say exactly:
"I don't have enough information to answer this question."
 
### CONTEXT DOCUMENTS
[Doc 1] Employees get 20 paid vacation days per year.
[Doc 2] Vacation days do not roll over to the next year.
[Doc 3] Remote work is allowed on Fridays with manager approval.
 
### FEW-SHOT EXAMPLES
Question: "Can I work from home on Friday?"
Answer: Yes, remote work is allowed on Fridays if you have manager
approval [Doc 3].
Sources: Doc 3
 
Question: "How many vacation days carry over to next year?"
Answer: Vacation days do not roll over to the next year [Doc 2].
This means any days you do not use are lost when the year ends.
Sources: Doc 2
 
### FALLBACK
If the documents do not contain the answer, say:
"I don't have enough information to answer this question."
 
### CONFIDENCE / ESCALATION
If the documents contain some related information but not enough
to fully answer the question, explain what you know and what is
still missing.

import os
from dotenv import load_dotenv
from groq import Groq
 
load_dotenv()
 
GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
if not GROQ_API_KEY:
    raise ValueError("Provide Groq API key")
 
client = Groq(api_key=GROQ_API_KEY)
model = "llama-3.3-70b-versatile"
 
def classify_complaint(user_message: str) -> str:
  """Sort a user complaint into one category."""
 
  system_prompt = """
  ### ROLE
  You are a support assistant at a consumer electronics company.
  You handle the first step of sorting user complaints.
 
  ### TASK
  Put the user's complaint into one category.
 
  ### CONSTRAINTS
  Use ONLY: Billing, Technical, Return.
  Do not create new categories.
  Do not combine categories.
 
  ### PROCESS (do this silently before answering)
  Step 1: Does the user mention a billing issue? (Yes/No)
  Step 2: Does the user mention a technical problem? (Yes/No)
  Step 3: Does the user mention a return or refund? (Yes/No)
 
  After these checks:
  - If only ONE category has a Yes, pick that category.
  - If TWO OR MORE categories have a Yes, respond with Needs Review.
  - If NO category has a Yes, respond with Other.
 
  ### OUTPUT FORMAT
  Respond with exactly ONE WORD.
  No punctuation. No explanation.
  No spaces before or after the word.
 
  ### FEW-SHOT EXAMPLES
  Input: "I want a refund for my phone" -> Return
  Input: "My screen won't turn on" -> Technical
  Input: "I was charged twice for one order" -> Billing
  Input: "Do you sell phone cases?" -> Other
  Input: "The keyboard stopped working and I want my money back" -> Needs Review
  Input: "The battery drains fast. I got this two days ago." -> Needs Review
 
  ### FALLBACK
  If the input is not about Billing, Technical, or Return,
  respond with: Other
 
  ### CONFIDENCE / ESCALATION
  If the input fits two or more categories, respond with: Needs Review
  """
 
  response = client.chat.completions.create(
    model=model,
    messages=[
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": user_message},
    ],
    temperature=0,
  )
 
  return response.choices[0].message.content.strip()
 
# Test it
test_cases = [
    ("The laptop screen is flickering, and I just bought it.", "Needs Review"),
    ("My girlfriend left me", "Other"),
    ("I was charged twice for the same order", "Billing"),
    ("The screen won't turn on", "Technical"),
    ("I want to return my headphones", "Return"),
]
 
print("Testing the classification prompt:\n")
for complaint, expected in test_cases:
    result = classify_complaint(complaint)
    status = "✓" if result == expected else f"✗ (got '{result}')"
    print(f"{status} Expected: {expected:<15} | Input: {complaint}")

You ask a question → Model gives an answer

You ask a question
  → Model thinks about what it needs
  → Model calls a tool
  → You run the tool and give the result back
  → Model thinks again
  → Model might call another tool
  → This repeats until the model has enough information
  → Model gives a final answer

User Question
    │
    ▼
[ Thought ]     → The model writes down what it needs to do next.
    │
    ▼
[ Action ]      → The model picks a tool and provides the input.
    │
    ▼
[ Observation ] → Your code runs the tool and gives the result back.
    │
    ▼
(Repeat until the LLM decides it has enough information)
    │
    ▼
[ Final Answer ]

import Groq from "groq-sdk";
import { config } from "dotenv";
 
// Load env
config();
 
const GROQ_API_KEY = process.env.GROQ_API_KEY;
if (!GROQ_API_KEY) {
  throw new Error("Provide Groq API key");
}
 
const client = new Groq({ apiKey: GROQ_API_KEY });
const model = "llama-3.3-70b-versatile";
 
// Tools
function getProductPrice(product) {
  if (product === "iPhone 17") {
    return 100_000;
  } else if (product === "iPhone 15") {
    return 50_000;
  } else {
    return 0;
  }
}
 
function calculator(expression) {
  try {
    return eval(expression);
  } catch {
    return "calc error!";
  }
}
 
const tools = {
  getProductPrice: getProductPrice,
  calculator: calculator,
};
 
const system_prompt = `
You are a shopping assistant.
 
You have these tools:
getProductPrice(product)
calculator(expression)
 
IMPORTANT:
Call tools exactly like these examples:
 
Action: getProductPrice("iPhone 17")
Action: calculator("5000 - 1000")
 
Never write:
getProductPrice({ product: "iPhone 17" })
 
Never write:
calculator({ expression: "5000 - 1000" })
 
Follow these rules:
1. Decide what you need to do next.
2. Call ONLY ONE tool at a time.
3. After writing an Action, STOP immediately.
4. Never guess or invent a tool result.
5. Wait until you receive an observation.
6. Then decide your next action.
7. When the task is complete, give the Final Answer.
 
Format:
 
Thought: what you need to do
Action: toolName(argument)
 
When finished:
 
Final Answer: your answer
`;
 
function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}
 
async function runAgent(question) {
  console.log("\n" + "=".repeat(50));
  console.log("🤖 AGENT STARTED");
  console.log("=".repeat(50));
  console.log("Question:", question);
 
  const messages = [
    {
      role: "system",
      content: system_prompt,
    },
    {
      role: "user",
      content: question,
    },
  ];
 
  for (let step = 0; step < 5; step++) {
    console.log("\n------------------");
    console.log("STEP", step + 1);
    console.log("------------------");
 
    const response = await client.chat.completions.create({
      model: model,
      messages: messages,
      temperature: 0,
    });
 
    const answer = response.choices[0].message.content;
 
    console.log(answer);
 
    // Agent has finished
    if (answer.includes("Final Answer")) {
      break;
    }
 
    // Find the Action
    const match = answer.match(/Action:\s*(\w+)\((.*?)\)/);
 
    if (match) {
      const tool_name = match[1];
      let tool_input = match[2];
      tool_input = tool_input.trim();
      tool_input = tool_input.replace(/['"]/g, "");
 
      // Run the tool
      let observation;
      if (tool_name in tools) {
        const tool = tools[tool_name];
        observation = tool(tool_input);
      } else {
        observation = "Tool not found";
      }
 
      console.log("Observation:", observation);
 
      // Add LLM response to memory
      messages.push({
        role: "assistant",
        content: answer,
      });
 
      // Give tool result back to LLM
      messages.push({
        role: "user",
        content: "Observation: " + observation,
      });
 
      await sleep(5000);
    }
  }
}
 
const prompt = `
I have 500_000 taka. What is the price of an iphone 17?
and how much money will I have left?
`;
 
runAgent(prompt);

import os
from dotenv import load_dotenv
from groq import Groq
from time import sleep
 
# Load env
load_dotenv()
 
GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
if not GROQ_API_KEY:
  raise ValueError("Provide Groq API key")
 
client = Groq(api_key=GROQ_API_KEY)
model = "llama-3.3-70b-versatile"
 
JOB_DESCRIPTION = """
We are hiring a Backend Python Developer.
 
Requirements:
- Strong Python
- FastAPI or Django
- PostgreSQL
- Docker
- AWS
- REST APIS
- 2+ years of experience
"""
 
RESUME = """
Name: Rezwan Rahman
 
Experience:
3 years as a Software Developer.
 
Skills:
Python, FastAPI, MySQL, Docker,
REST APIs, Git
 
Projects:
Built a food delivery backend using
FastAPI and MySQL.
 
Deployed applications using Docker.
"""
 
def ask_llm(system_prompt, user_prompt):
  sys_msg = {
    "role": "system",
    "content": system_prompt,
  }
  user_msg = {
    "role": "user",
    "content": user_prompt,
  }
 
  messages = [sys_msg, user_msg]
  response = client.chat.completions.create(model=model, messages=messages)
  answer = response.choices[0].message.content
  return answer
 
def step1_resume_extract():
  system_prompt = """
  You are a professional HR assistant. Extract the skills from the candidates resume provided.
  Only return the skills no other information. Do not invent any skills by yourself.
  Output Format:
  Skills should be separated by commas. Just return comma separated skills do not return any others
  filler information.
  """
 
  user_prompt = f"""
  Extract the skills from this resume
  {RESUME}
  """
 
  return ask_llm(system_prompt, user_prompt)
 
def step2_job_description_extract():
  system_prompt = """
  You are a professional HR assistant. Extract the skills from the Job description provided.
  Only return the skills no other information. Do not invent any skills by yourself.
  Output Format:
  Skills should be separated by commas. Just return comma separated skills do not return any others
  filler information.
  """
 
  user_prompt = f"""
  Extract the skills from this Job description
  {JOB_DESCRIPTION}
  """
 
  return ask_llm(system_prompt, user_prompt)
 
def step3_match(candidate, job_description):
  system_prompt = """
  You are a professional HR assistant, compare the skills of the candidate and
  the skills required in the Job description and produce a final score between 1 and 100.
  Also produce a short verdict whether the candidate is a good fit for the role.
  """
 
  user_prompt = f"""
  Compare and match the skills
 
  Job Description:
  {job_description}
 
  Candidate:
  {candidate}
  """
 
  return ask_llm(system_prompt, user_prompt)
 
def main():
  candidate = step1_resume_extract()
  sleep(2)
 
  job_description = step2_job_description_extract()
  sleep(2)
 
  score = step3_match(candidate, job_description)
  print(score)
 
main()

import { GoogleGenAI } from "@google/genai";
 
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
 
const response = await ai.models.generateContent({
  model: "gemini-2.5-flash",
  config: {
    responseMimeType: "application/json", // Forces JSON output
    responseSchema: {
      type: "object",
      properties: {
        category: { type: "string", enum: ["Billing", "Technical", "Return"] },
        confidence: { type: "number", minimum: 0, maximum: 1 },
        summary: { type: "string", maxLength: 100 },
      },
      required: ["category", "confidence", "summary"],
    },
  },
  contents: [
    { role: "user", parts: [{ text: "I was charged twice for my order" }] },
  ],
});
 
const result = JSON.parse(response.text);
console.log(result.category); // "Billing"
console.log(result.confidence); // 0.95

import { z } from "zod";
 
// Define the schema once — use it for both the API and validation
const TicketSchema = z.object({
  category: z.enum(["Billing", "Technical", "Return"]),
  confidence: z.number().min(0).max(1),
  summary: z.string().max(100),
});
 
// After getting the response
try {
  const parsed = TicketSchema.parse(JSON.parse(response.text));
  // parsed is now fully typed and validated
  console.log(parsed.category);
} catch (error) {
  // Log the failure, retry, or return a fallback
  console.error("Schema validation failed:", error);
}

async function generateStructuredContent(prompt, schema, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const response = await ai.models.generateContent({
      model: "gemini-2.5-flash",
      config: {
        responseMimeType: "application/json",
        responseSchema: schema,
      },
      contents: [{ role: "user", parts: [{ text: prompt }] }],
    });
 
    try {
      return JSON.parse(response.text);
    } catch {
      if (attempt === maxRetries - 1)
        throw new Error("Failed after max retries");
      // Optionally add feedback to the prompt on retry
      prompt = `${prompt}\n\nYour previous response was invalid. Ensure it matches the schema exactly.`;
    }
  }
}

const tools = [
  {
    functionDeclarations: [
      {
        name: "getProductPrice",
        description: "Get the current price of a product by name",
        parameters: {
          type: "object",
          properties: {
            product: {
              type: "string",
              description: "The product name (e.g., 'iPhone 17')",
            },
          },
          required: ["product"],
        },
      },
      {
        name: "calculator",
        description: "Evaluate a mathematical expression",
        parameters: {
          type: "object",
          properties: {
            expression: {
              type: "string",
              description: "The expression to evaluate (e.g., '2 + 2')",
            },
          },
          required: ["expression"],
        },
      },
    ],
  },
];

const response = await ai.models.generateContent({
  model: "gemini-2.5-flash",
  config: {
    tools: tools,
    systemInstruction:
      "You are a shopping assistant. Use tools to get accurate information.",
  },
  contents: [
    {
      role: "user",
      parts: [
        {
          text: "I have 500,000 taka. What is the price of an iPhone 17, and how much will I have left?",
        },
      ],
    },
  ],
});
 
// Check if the model wants to call a function
const functionCalls = response.candidates?.[0]?.content?.parts?.filter(
  (part) => part.functionCall,
);
 
if (functionCalls?.length) {
  for (const call of functionCalls) {
    const { name, args } = call.functionCall;
    console.log(`Model wants to call:${name}(${JSON.stringify(args)})`);
    // Execute the function and return the result...
  }
}

async function runWithFunctionCalling(userPrompt) {
  const messages = [{ role: "user", parts: [{ text: userPrompt }] }];
 
  while (true) {
    const response = await ai.models.generateContent({
      model: "gemini-2.5-flash",
      config: { tools },
      contents: messages,
    });
 
    const parts = response.candidates?.[0]?.content?.parts || [];
 
    // Check for function calls
    const functionCalls = parts.filter((p) => p.functionCall);
 
    if (functionCalls.length === 0) {
      // No function calls — this is the final answer
      return response.text;
    }
 
    // Add model's response to history
    messages.push({
      role: "model",
      parts: parts,
    });
 
    // Execute each function call and collect results
    const functionResults = [];
    for (const call of functionCalls) {
      const { name, args } = call.functionCall;
      const result = executeFunction(name, args); // Your function execution logic
      functionResults.push({
        functionResponse: {
          name: name,
          response: { result: result },
        },
      });
    }
 
    // Return function results to the model
    messages.push({
      role: "tool",
      parts: functionResults,
    });
  }
}
 
function executeFunction(name, args) {
  switch (name) {
    case "getProductPrice":
      return args.product === "iPhone 17" ? 100000 : 0;
    case "calculator":
      return eval(args.expression); // Use a safe evaluator in production
    default:
      return "Unknown function";
  }
}

// If the user asks: "What's the price of iPhone 17 and iPhone 15?"
// The model might return TWO functionCalls in a single response:
// functionCall: getProductPrice({ product: "iPhone 17" })
// functionCall: getProductPrice({ product: "iPhone 15" })

Client: POST /chat { "prompt": "Explain quantum computing" }
Server: data: {"token": "Quantum"}
Server: data: {"token": " computing"}
Server: data: {"token": " is"}
Server: data: {"token": " a"}
Server: data: {"token": " field"}
...
Server: data: [DONE]

const stream = await ai.models.generateContentStream({
  model: "gemini-2.5-flash",
  contents: [
    { role: "user", parts: [{ text: "Explain TypeScript generics" }] },
  ],
});
 
for await (const chunk of stream) {
  const text = chunk.text;
  if (text) {
    process.stdout.write(text); // Print each chunk as it arrives
  }
}

let fullResponse = "";
 
for await (const chunk of stream) {
  const text = chunk.text;
  if (text) {
    fullResponse += text;
    // DON'T try to JSON.parse() here — it's incomplete
  }
}
 
// Only parse when the stream is complete
const result = JSON.parse(fullResponse);

const controller = new AbortController();
const timeout = setTimeout(() => controller.abort(), 30000); // 30-second timeout
 
try {
  const stream = await ai.models.generateContentStream(
    {
      model: "gemini-2.5-flash",
      contents: [{ role: "user", parts: [{ text: prompt }] }],
    },
    { signal: controller.signal },
  );
 
  for await (const chunk of stream) {
    // Process chunk...
  }
} catch (error) {
  if (error.name === "AbortError") {
    console.log("Stream cancelled or timed out");
  }
} finally {
  clearTimeout(timeout);
}

async function generateWithRetry(requestConfig, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await ai.models.generateContent(requestConfig);
    } catch (error) {
      // Don't retry on permanent errors
      if (
        error.status === 400 ||
        error.status === 401 ||
        error.status === 403
      ) {
        throw error; // Bad request, auth failure, forbidden — retrying won't help
      }
 
      if (attempt === maxRetries - 1) {
        throw error; // Last attempt failed — give up
      }
 
      // Exponential backoff with jitter
      const delay = Math.min(1000 * Math.pow(2, attempt), 30000); // Cap at 30 seconds
      const jitter = Math.random() * 1000; // Add up to 1 second of randomness
      await sleep(delay + jitter);
 
      console.log(`Retry${attempt + 1}/${maxRetries} after${delay}ms`);
    }
  }
}

async function classifyComplaint(userMessage) {
  try {
    return await generateWithRetry({
      model: "gemini-2.5-flash",
      config: {
        responseMimeType: "application/json",
        responseSchema: TicketSchema,
      },
      contents: [{ role: "user", parts: [{ text: userMessage }] }],
    });
  } catch (error) {
    console.error("Classification failed:", error);
 
    // Fallback strategies in order of preference:
    // 1. Use a simpler, faster model
    // 2. Return a default value that triggers human review
    // 3. Ask the user to try again later
 
    return {
      category: "Needs Review",
      confidence: 0,
      summary: "Classification failed — requires manual review",
    };
  }
}

class RateLimiter {
  private queue: Array<() => void> = [];
  private processing = false;
  private lastCallTime = 0;
 
  constructor(private minIntervalMs: number) {}
 
  async waitForSlot(): Promise<void> {
    const now = Date.now();
    const timeSinceLastCall = now - this.lastCallTime;
 
    if (timeSinceLastCall < this.minIntervalMs) {
      await sleep(this.minIntervalMs - timeSinceLastCall);
    }
 
    this.lastCallTime = Date.now();
  }
}
 
// Usage: max 10 calls per second
const limiter = new RateLimiter(100);
 
async function rateLimitedGenerate(requestConfig) {
  await limiter.waitForSlot();
  return generateWithRetry(requestConfig);
}

class CircuitBreaker {
  private failures = 0;
  private lastFailureTime = 0;
  private state: "closed" | "open" | "half-open" = "closed";
 
  constructor(
    private failureThreshold: number = 5,
    private resetTimeout: number = 30000 // 30 seconds
  ) {}
 
  async call<T>(fn: () => Promise<T>): Promise<T> {
    if (this.state === "open") {
      if (Date.now() - this.lastFailureTime > this.resetTimeout) {
        this.state = "half-open";
      } else {
        throw new Error("Circuit breaker is open");
      }
    }
 
    try {
      const result = await fn();
      this.failures = 0;
      this.state = "closed";
      return result;
    } catch (error) {
      this.failures++;
      this.lastFailureTime = Date.now();
 
      if (this.failures >= this.failureThreshold) {
        this.state = "open";
      }
 
      throw error;
    }
  }
}

function estimateCost(model, inputTokens, outputTokens) {
  const pricing = {
    "gemini-2.5-flash": { input: 0.15, output: 0.6 },
    "gemini-2.5-pro": { input: 1.25, output: 10.0 },
  };
 
  const modelPricing = pricing[model];
  const inputCost = (inputTokens / 1_000_000) * modelPricing.input;
  const outputCost = (outputTokens / 1_000_000) * modelPricing.output;
 
  return inputCost + outputCost;
}
 
// Example: 1000 input tokens, 500 output tokens with flash
console.log(estimateCost("gemini-2.5-flash", 1000, 500)); // ~$0.00045

function trimConversationHistory(messages, maxTokens = 4000) {
  let tokenCount = 0;
  const trimmed = [];
 
  // Work backwards — keep most recent messages
  for (let i = messages.length - 1; i >= 0; i--) {
    const estimatedTokens = estimateTokens(messages[i]); // ~4 chars per token
    if (tokenCount + estimatedTokens > maxTokens) break;
    trimmed.unshift(messages[i]);
    tokenCount += estimatedTokens;
  }
 
  return trimmed;
}
 
function estimateTokens(text) {
  return Math.ceil(text.length / 4); // Rough estimate for English
}