What is Prompt Evaluation?

Prompt Evaluation is the process of assessing how well a prompt meets defined quality criteria, using a consistent and repeatable method.

We all know LLM output is non-deterministic, unlike a programming language. For a normal function, we can know what the output will be based on the input we pass, so we can test this function with various cases(inputs) using a testing library such as pytest. Eventually, we know how this function will work under various scenarios.

How do we do such tests for LLM output with various inputs when LLM output is non-deterministic? LLM results are completely based on the params we have passed. Then how do we assess the quality of the params? — That is what Prompt Evaluation is for.

DeepEval:

DeepEval is one of the prompt evaluation libraries. Using this we can test LLM output like how we are doing unit-test using pytest. Not only that; it provides various features such as evaluating AI agents, voice agents, multi-turn chatbots, RAG pipelines, MCP systems, and other custom workflows.

Evaluation Techniques & Metrics:

1. Faithfulness — It extracts individual claims from the output and checks them against the context using LLM-as-judge. RAG pipelines must ensure the generator is not making up facts outside the provided source documents.
2. Answer Relevancy — It checks, based on the input, the number of relevant statements in the overall result (Number of relevant statements / Total result). It helps us catch off-topic drift.
3. G-Eval — Using G-Eval, we can check our custom criteria. We can check whether any of our specific custom rules worked as expected.

Golden test cases:

We can define our own golden test cases (input and expected output). We can pass them to the test function @pytest.mark.parametrize and test all golden cases.

Example:

We can build a simple AI chat application and implement the above DeepEval techniques.

Create a project directory

mkdir customer-support-ai
cd customer-support-ai

Create a virtual environment

python3 -m venv .eval_env
source .eval_env/bin/activate

Install required dependencies.

First, create a requirements.txt file and add the following libs.

google-genai
deepeval
fastapi
uvicorn
python-dotenv
scikit-learn
pytest

Then, install everything.

$ python -m pip install -r requirements.txt

Create environment variables

Create a .env file in the project root directory.

GOOGLE_API_KEY=your_gemini_api_key
GEMINI_MODEL=gemini-2.5-flash

We can create a simple knowledge base folder that contains three simple text files. Our AI chatbot will answer based on these three files.

$ mkdir app
$ cd app
$ mkdir knowledge_base
$ cd knowledge_base

Under the knowledge_base folder, add these three files.

1. cancellation_policy.txt

Cancellation Policy

1. Customers can cancel an order before it is shipped.

2. Orders that have already been shipped cannot be cancelled.

3. For shipped orders, customers must follow the return policy.

2. return_policy.txt

Return Policy

1. Customers can return eligible products within 30 days
   of delivery.

2. Products must be unused and in their original packaging.

3. Refunds are processed within 5-7 business days
   after the returned product is approved.

3. shipping_policy.txt

Shipping Policy

1. Standard delivery takes 3-5 business days.

2. Express delivery takes 1-2 business days.

3. Customers receive a tracking link after dispatch.

Once we have added these three files, we can implement retriever.py to read these files based on the question (input) using a vector search approach.

Under the app folder, create retriever.py file.

from pathlib import Path
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

BASE_DIR = Path(__file__).parent / "knowledge_base"

documents = [file.read_text() for file in BASE_DIR.glob("*.txt")]

vectorizer = TfidfVectorizer(stop_words="english")
document_vectors = vectorizer.fit_transform(documents)


def retrieve_documents(question, top_k=2):
    question_vector = vectorizer.transform([question])

    scores = cosine_similarity(question_vector, document_vectors)[0]

    top_indices = scores.argsort()[::-1][:top_k]

    return [documents[i] for i in top_indices]

Instead of explaining every line of the above function (since we are focusing on DeepEval), I will provide a high-level explanation — it reads content from the document based on the question using a vector search approach.

Create the chatbot.py file under the app folder.

import os
from dotenv import load_dotenv
from google import genai
from app.retriever import retrieve_documents

load_dotenv()

client = genai.Client(api_key=os.getenv("GOOGLE_API_KEY"))
MODEL = os.getenv("GEMINI_MODEL")

def ask_customer_support(question):
    # 1. Retrieve relevant documents
    context = retrieve_documents(question)

    # 2. Prepare the prompt
    prompt = f"""
    You are a customer support assistant.

    Answer the customer's question using only
    the information in the provided context.

    If the answer is not available in the context,
    clearly say that you don't have enough information.

    Context:
    {context}

    Customer question:
    {question}

    Answer:
    """

    # 3. Call Gemini
    response = client.models.generate_content(model=MODEL, contents=prompt)

    # 4. Return answer and retrieved context
    return {"question": question, "answer": response.text, "retrieval_context": context}

The above function first calls retrieve_documents function to get the relevant information from the document and set it as the context for the LLM prompt; then we add the question. Finally, we make an LLM call to get the answer to the question only based on the context.

Create main.py under the app folder.

from fastapi import FastAPI
from app.chatbot import ask_customer_support

app = FastAPI()


@app.get("/chat")
def chat(question: str):
    return ask_customer_support(question)

The above code just defines a chat API which calls ask_customer_support function to get the answer.

Project implementation is done. Now move to testing our LLM implementation.

Test case implementation

Now create a tests folder in the project root directory, then create a test_chatbot.pyfile.

First, import required libs for testing.

import os
import pytest
from dotenv import load_dotenv

from deepeval import assert_test
from deepeval.metrics import FaithfulnessMetric, AnswerRelevancyMetric, GEval
from deepeval.test_case import LLMTestCase, SingleTurnParams
from deepeval.models import GeminiModel

from app.chatbot import ask_customer_support
from tests.test_cases import test_cases # We can define this later

load_dotenv()

Here, a few items we need to note.

assert_test — This is for testing the defined test cases, as we can pass test cases and metrics as arguments.

FaithfulnessMetric, AnswerRelevancyMetric, GEval — These three items are the metrics we are using to evaluate the prompt.

GeminiModel — We are using GeminiModel as an LLM-as-a-judge.

LLMTestCase, SingleTurnParams — These two methods are for defining test cases.

Define Metrics:

gemini_model = GeminiModel(
    model=os.getenv("GEMINI_MODEL"), api_key=os.getenv("GOOGLE_API_KEY")
)

faithfulness = FaithfulnessMetric(threshold=0.7, model=gemini_model)

answer_relevency = AnswerRelevancyMetric(threshold=0.7, model=gemini_model)

policy_compliance = GEval(
    name="Policy Compliance",
    criteria="""
         Evaluate whether the assistant follows the company policies.

    The assistant must not:
    1. Invent return or refund policies.
    2. Promise exceptions not mentioned in the context.
    3. Provide information that contradicts the policy.

    Give a high score when the answer follows these rules.
    """,
    evaluation_params=[
        SingleTurnParams.INPUT,
        SingleTurnParams.ACTUAL_OUTPUT,
        SingleTurnParams.RETRIEVAL_CONTEXT,
        SingleTurnParams.EXPECTED_OUTPUT,
    ],
    threshold=0.7,
    model=gemini_model,
)

In the above code, we have defined faithfulness, answer relevancy, and policy compliance metrics. In each item, we have passed a threshold and a model.

Define Golden test cases:

Under the tests folder, create a test_cases.py file with the following code as the sample test cases (input and expected behaviour).

test_cases = [
    {
        "input": "Can I return a product after 20 days?",
        "expected_behavior": "Explain the 30-day return policy.",
    },
    {
        "input": "Can I return a product after 45 days?",
        "expected_behavior": "Explain that the return period is 30 days.",
    },
    {
        "input": "How long does shipping take?",
        "expected_behavior": "Explain standard and express delivery times.",
    },
    {
        "input": "Can I cancel an order after shipping?",
        "expected_behavior": "Explain that shipped orders cannot be cancelled.",
    },
    {
        "input": "Do you sell mobile phones?",
        "expected_behavior": "Do not invent product information.",
    },
]

Define a test case and a testing function

@pytest.mark.parametrize("test_data", test_cases)
def test_return_policy(test_data):
    result = ask_customer_support(test_data["input"])

    test_case = LLMTestCase(
        input=result["question"],
        actual_output=result["answer"],
        expected_output=test_data["expected_behavior"],
        retrieval_context=result["retrieval_context"],
    )

    assert_test(test_case, [faithfulness, answer_relevency, policy_compliance])

In the above code, using parameterize approach, we are passing those test_cases to the test_return_policy function; it runs each test case.

result = ask_customer_support(test_data[“input”]) — This statement takes input from the test_case and passes it to the ask_customer_support function, which gets answers from the LLM.

test_case = LLMTestCase(
        input=result["question"],
        actual_output=result["answer"],
        expected_output=test_data["expected_behavior"],
        retrieval_context=result["retrieval_context"],
    )
 assert_test(test_case, [faithfulness, answer_relevency, policy_compliance])

Once we get the result, we can pass it to the LLMTestCase method. The result dictionary has question, answer, and retrieval_contextalong with this, we are passing expected_behavior from test_case .

assert_test(test_case, [faithfulness, answer_relevency, policy_compliance]) — This is the final statement to test and give the result. We passed test_case as the first argument, then metrics as the second argument.

Now run the test cases:

$ deepeval test run tests/test_chatbot.py

Output is:

Note: Due to the API rate limit, I kept only one test case for this test run.

The screenshot shows the results of the test cases for the defined metrics. This is how we can test the quality and consistency of the LLM implementation in our application.

Thank you for reading. Have a nice day!

Reference Links:

https://deepeval.com/docs/introduction

Source Code:

• GitHub - EdisonDevadoss/deep_eval_customer_support_ai
• GitHub - EdisonDevadoss/deep_eval_tutorial

I have been working on a few FastAPI projects where I need to write unit test cases, but I am using Claude-code to write those test cases, run the test cases, and ensure all the items are green (successfully run ). I feel I am not understanding how pytest works and the nitty-gritty of the library.

Then I started to watch a YouTube video (freeCodeCamp course) learnt basics of the pytest library and how to use it to write test cases. This is what I used to do before AI-assisted coding.

What is pytest

It is the most widely used Python testing framework, which we can use with any backend library, whether it is FastAPI, Django or Flask, or a plain Python script; pytest works smoothly.

Core Features:

Auto-discovery of tests: Pytest has the ability to pick up tests based on how we name them. The pytest command automatically discovers all tests.

Rich Assertion Introspection: Pytest automatically provide detailed and readable error messages when a plain assert statement fails.

Support parameterised and fixture-based testing: Using the parameterisation approach, we can run a test function multiple times with different inputs. Fixtures set up the environment for test cases that need to run (e.g., open a database connection before running the test cases).

Installation and setup:

First, we need to create a virtual environment

python3 -m venv venv
source venv/bin/activate

Then, install ptyest

$ pip install -U pytest
$ pytest --version

We can take a simple project as an example to write basic tests.

First, we can write test cases for a simple function

# my_functions.py
def add(number_one, number_two):
    return number_one + number_two


def divide(number_one, number_two):
    if number_two == 0:
        raise ValueError

    return number_one / number_two

Now we can write test cases for the above two functions. It is just adding and dividing numbers.

$ mkdir tests
$ cd tests
$ touch test_my_functions.py

First, import the necessary items in the test_my_functions.py file

import pytest
import time
import source.my_functions as my_functions

Now we can write test cases for the add function

def test_add():
    result = my_functions.add(number_one=1, number_two=4)

    assert result == 5

The above one is simple; just create a function test_add and call the my_functions.add inside the function and get the result. Then, using assert, compare the result. If it matches, the test case passes.

Run the test cases

$  python -m pytest tests/test_my_functions.py

This is a simple example of how to write unit test cases for a simple function.

Write test cases for a Class:

Create a file shape.py and add the lines of code.

import math

class Shape:

    def area(self):
        pass

    def perimeter(self):
        pass


class Circle(Shape):

    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return math.pi * self.radius**2

    def perimeter(self):
        return 2 * math.pi * self.radius

It just creates a Circle, and using the Shape class, we can create multiple shapes later.

Now I am creating a test case file for the Circle class under the tests folder: test_circle.py

import pytest
import source.shapes as shapes
import math


class TestCircle:

    def setup_method(self, method):
        print(f"Setting up {method}")
        self.circle = shapes.Circle(10)

    def teardown_method(self, method):
        print(f"Teardown {method}")

        del self.circle

    def test_radius(self):
        assert self.circle.area() == math.pi * self.circle.radius**2

    def test_one(self):
        assert True

    def test_perimeter(self):
        result = self.circle.perimeter()
        expectec = 2 * math.pi * self.circle.radius

        assert result == expectec

    def test_not_same_area_rectangle(self, my_rectangle):
        assert self.circle.area() != my_rectangle.area()

I have provided my entire test suite for the Circle class. Here, a couple of things we need to notice: there are two functions it has, but it nothing to do with testing the Circle class, but it is essential. Those two functions are setup_method() and teardown_method() . These two functions are part of pytest lifecycle methods. They will be automatically called before and after each test method is called.

Run the test cases

$ python -m pytest tests/test_circle.py -s

s — This option ensure to see the print statements.

See the output below:

$ python -m pytest tests/test_circle.py -s
========================================================================================== test session starts ===========================================================================================
platform darwin -- Python 3.13.11, pytest-9.1.1, pluggy-1.6.0
rootdir: /Users/mahendran/Edison/learnings/python/fastapi/pytest-fcc
collected 4 items                                                                                                                                                                                        

tests/test_circle.py Setting up <bound method TestCircle.test_radius of <test_circle.TestCircle object at 0x101700e10>>
.Teardown <bound method TestCircle.test_radius of <test_circle.TestCircle object at 0x101700e10>>
Setting up <bound method TestCircle.test_one of <test_circle.TestCircle object at 0x101701590>>
.Teardown <bound method TestCircle.test_one of <test_circle.TestCircle object at 0x101701590>>
Setting up <bound method TestCircle.test_perimeter of <test_circle.TestCircle object at 0x10167a060>>
.Teardown <bound method TestCircle.test_perimeter of <test_circle.TestCircle object at 0x10167a060>>
Setting up <bound method TestCircle.test_not_same_area_rectangle of <test_circle.TestCircle object at 0x10167a3f0>>
.Teardown <bound method TestCircle.test_not_same_area_rectangle of <test_circle.TestCircle object at 0x10167a3f0>>


=========================================================================================== 4 passed in 0.00s ============================================================================================

In the output above, we can see that setup_method is called before each function is called, and teardown_method is called after each function is called.

Fixture

Now we will see another important feature: Fixture.

A fixture is for setting up the environment for test cases that we need to run. If we have common fixtures and they are going to be used in multiple places, we can create a conftest.py file and write common fixtures there. We do not need to import the conftest.py file in each of our test case files. It automatically finds the conftest file.

First, we can add one more class, Rectangle, in the shape.py file

class Rectangle(Shape):

    def __init__(self, length, width):
        self.length = length
        self.width = width

    def __eq__(self, other):
        if not isinstance(other, Rectangle):
            return False

        return self.width == other.width and self.length == other.length

    def area(self):
        return self.length * self.width

    def perimeter(self):
        return (self.length * 2) + (self.width * 2)

Create a conftest.py file

$ cd tests
$ touch conftest.py

Now we add fixtures for rectangle creation.

# conftest.py
import pytest
import source.shapes as shapes


@pytest.fixture
def my_rectangle():
    return shapes.Rectangle(10, 20)


@pytest.fixture
def weird_rectangle():
    return shapes.Rectangle(5, 6)

Here, I have created fixtures that I can use in other places.

Create a test_rectangle.py file

# test_rectangle.py

import pytest

def test_area(my_rectangle):
    assert my_rectangle.area() == 10 * 20


def test_perimeter(my_rectangle):

    assert my_rectangle.perimeter() == (10 * 2) + (20 * 2)


def test_not_equal(my_rectangle, weird_rectangle):
    assert my_rectangle != weird_rectangle

Here, this test file automatically reads the conftest.py, and it automatically passes the my_rectangle function as a parameter. Using this approach, we can reuse common functions.

Thank you for reading. Have a nice day!

Reference Links:

GitHub source code: https://github.com/EdisonDevadoss/pytest-fundamentals

Video Reference: https://www.youtube.com/watch?v=cHYq1MRoyI0

What is RAG:

The RAG (Retrieval-Augmented Generation) fetches external and up-to-date information and gives it to the LLM for answering users’ questions.

Without RAG, LLM answers only from their model-trained data. If the user asks anything beyond that, the LLM cannot answer such questions. But, RAG, as a knowledge base, provides those capabilities to the LLM.

Then, what is RAG-Agent?

A RAG (Retrieval-Augmented Generation) Agent is an AI system that combines a Large Language Model (LLM) with an external knowledge base, allowing it to retrieve factual, up-to-date information before generating an answer, making responses more accurate, context-aware, and less prone to hallucination.

In the traditional RAG system, whenever a user ask question, we have to embed (vectorise) that question, then using that embedding we need to find relevant matches in the vector database. Once we get the relevant matches from the vector database, then we need to pass them to the LLM. Based on the relevant matches, LLM will answer users’ questions.

But, in RAG-Agent, we do not need to embed manually, find relevant matches from the vector database and pass them to the LLM.

I will show how to implement a simple RAG agent. In this project, I am using FastAPI and a few LangChain libraries.

Step 1: Project creation & installation

$ mkdir rag_agent
$ cd rag_agent

Virtual environment creation and activation (For Mac and Ubuntu, you can follow the below one for venv creation, but for Windows, it slightly changes)

$ python3 -m venv .venv
$ source .venv/bin/activate

Package installation

$ touch requirement.txt

And add the following packages to the requirements.txt file

python-dotenv
fastapi
langchain[anthropic]
langchain
langchain_community
langchain-text-splitters 
pypdf
langchain-huggingface
langchain-chroma

Step 2: Project and route configuration

$ touch main.py

Add the following configuration to the main.py file.

from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
from dotenv import load_dotenv

import my_profile

load_dotenv()
app = FastAPI()

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

app.include_router(my_profile.router)

@app.get("/")
def root():
    return { "hello": "World" }

Run the application

$ uvicorn main:app --reload

If you have uvicorn, we can run using that library. Now we see the running application on http://localhost:8000/

Step3: Langchain configuration

Create the my_profile.py file for our sample application and import the necessary packages.

from fastapi.routing import APIRouter
from langchain.agents import create_agent
from langchain_community.document_loaders import PyPDFLoader
from langchain.messages import HumanMessage, AIMessage
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain.tools import tool
from langchain_huggingface import HuggingFaceEmbeddings
from langchain_chroma import Chroma

router = APIRouter(tags=["my_profile"], prefix="/my_profile") 

Configure embedding

embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")

HuggingFaceEmbeddings is a Langchain wrapper class which connects with an embedding model. sentence-transformers/all-MiniLM-L6-v2 — It is an embedding model which we are using for text embedding.

Configure vector store

vector_store = Chroma(collection_name="my_profile", embedding_function=embeddings, persist_directory="./chroma_db")

The above one is my vector database configuration. I have chosen Chroma DB as my vector database. Here, one thing we have to note is embedding_function=embeddings — We have configured the embedding model when defining the vector store. So, it automatically converts our text into an embedding and stores it.

Defining tools

@tool(response_format="content_and_artifact")
def retrieve_context(query: str):
    """Retrieve information to help answer a query."""

    retrieved_docs = vector_store.similarity_search(query, k=2)
    serialized = "\n\n".join((f"Source: {doc.metadata}\nContent: {doc.page_content}")
                for doc in retrieved_docs
            )
    return serialized, retrieved_docs


def send_connection_email(sender_name: str, sender_email: str, message: str):
    """Send an email to Edison Devadoss when someone wants to connect."""
    try:

       print("sender mail", sender_email)
       print("sender name", sender_name)
       print("message", message)
        
    except Exception as e:
        return f"Error sending email: {str(e)}"

tools = [retrieve_context, send_connection_email]

Here, I have configured two tools, one for getting relevant matches from the vector store (retrieve_context). Another one is for sending an email message (Not fully implemented), but when it collected required details from the user, this function will be called. We can see the user’s email, name and message in the logs.

In this tool function writing doc_string is important; it helps LLM to identify when a particular function should be called.

Create agent

agent = create_agent(
    model="claude-sonnet-4-5-20250929",
    tools=tools,
    system_prompt="""You are Edison Devadoss's intelligent personal assistant. Your primary role is to provide information about Edison and facilitate connection requests.

## Your Responsibilities:

### 1. Answer Questions About Edison
- Respond ONLY to questions about Edison Devadoss using the knowledge base provided
- Use the retrive_context tool to search for relevant information
- Provide accurate, helpful answers based on Edison's professional profile, skills, experience, and background
- If information is not available in the knowledge base, politely inform the user that you don't have that information

### 2. Handle Connection Requests
When someone wants to connect with Edison:
- Collect their information in this order:
  * Full name
  * Email address
  * Brief reason for wanting to connect (what they'd like to discuss or collaborate on)
- Use the send_connection_email tool only after you have all three pieces of information
- Confirm the email has been sent successfully

## Important Guidelines:

- Stay focused on Edison's professional context only
- Do NOT answer general knowledge questions, trivia, or topics unrelated to Edison
- If asked about unrelated topics, politely redirect: "I'm specifically designed to help with questions about Edison Devadoss. How can I assist you with information about Edison?"
- Be professional, friendly, and concise in your responses
- Always verify information through the knowledge base before answering
- If someone asks something unrelated to Edison, do not attempt to answer—instead ask if they have questions about Edison

## Response Style:
- Be conversational yet professional
- Use a friendly tone
- Keep responses clear and concise
- Highlight Edison's relevant skills and experience when appropriate
"""
)

In the above code, we defined an agent with the following options.

1. Model
2. Tools
3. System prompt

We configured prefered LLM model, our tool function and system prompt.

Step 4: Store document in the Vector store:

@router.get("/")
def update_profile():
    loader = PyPDFLoader(
       "https://edisondevadoss.in/static/media/edison-resume.ce0cde934d768621e8f9.pdf"
    )

    docs = loader.load()
    text_spliter= RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
    all_splits = text_spliter.split_documents(docs)
    document_ids = vector_store.add_documents(documents=all_splits)
   
    return {"message": "Profile updated successfully"}

I have created an API endpoint (It is supposed to be a POST method), and whenever a user hits that endpoint, it reads my resume from the URL (It is a pdf document).

Then, using langchain_text_splitters, we split the texts. After splited we store them in the vector_store. It is stored as an embedding.

Step 5: Answers user’s question

# In production, use a database to persist conversations
conversation_history = []

@router.get("/ask")
def answer(query_txt: str):
    result = None
    conversation_history.append(HumanMessage(content=query_txt))

    response = agent.invoke(
        {"messages": conversation_history}
    )
    # Get the last message which should be the assistant's response
    if response and "messages" in response:
        last_message = response["messages"][-1]
        result = last_message.content
        conversation_history.append(AIMessage(content=result))
    
    return {"answer": result}

In the above code, first we have a conversation_history list where we are storing conversion, both the user’s question and the LLM’s response. If we want to establish a connection between one message and another, we need to maintain conversation history. So that LLM will consider the relevance of the current query with the previous list of messages. It helps LLM to understand the context better.

Whever user sends a query, we append it to the conversation_history list and pass the entire conversation_history to the agent’s invoke function. This will call the required tool and fetch the result from it, and give it to the LLM to answer users' questions.

Output:

In these two screenshots, the first one is storing docs in a vector database. The second one is after storing it, we are querying the RAG and fetching information.

Thank you for reading. Have a nice day!

Reference Link

Build a RAG agent with LangChain - Docs by LangChain

Github Source Code: https://github.com/EdisonDevadoss/LangChain-RAG-Agent

Hi, friends, I’m going to address the fundamentals, capabilities, and limitations of LLM in this post, which I learned in an Anthropic course.

Generative AI fundamentals:

We are all using AI every day without understanding what happend behine the scenes.

Generative AI refers to an Artificial Intelligence system that can create new content, rather than evaluate existing data.

Gen-AI has three pillars:

1. Algorithms — Natural Networks, Transformers Architecture
2. Data — Articles, websites, code and multimodal content
3. Computations — GPUS, TPUS, Computing clusters, etc.

Any LLM model consists of the three pillars mentioned above.

How to use the LLM: We can use an LLM model like delegating a task to a new employee and letting them do it on our behalf.

Limitation:

Below are the limitations of any LLM model:

• Knowledge cut-off date — As long as the model is trained, it contains data only up to that date. It will not have the current date’s (latest) data.
• Incorrect Information — The model might have trained with incorrect data.
• Hallucination — If an AI model is trained on a dataset comprising biased or unrepresentative data, it may hallucinate patterns or features that reflect these biases.
• AI Context Window — It models “Working Memory”, defining the maximum amount of text (input prompts, previous conversation turns, documents) it can process and remember at one time, measured in tokens (words or parts of words).

Now, I will explain the framework that helps us to bring the best output from LLM.

There are four competencies (4Ds):

• Delegation
• Description
• Discernment
• Diligence

These four components are important in dealing with AI. I will explain each of these.

Delegation:

Before using the LLM model, we should know three things.

1. What needs to be done?
2. What is AI going to do?
3. What are we going to do?

Once we know what works need to be done. Then, we should consider which task AI is going to do, and which task we are going to do. To do these, we should have project awareness and platform awareness (the capability of AI).

A person who has good knowledge in their field can drive more from AI

Description:

It is communicating with LLM. It is more than just a prompt.

The quality of LLM output depends on how clearly we describe what we want.

There are effective prompting techniques:

It is like explaining a task to a helpful new employee who is eager to assist us.

Fundamental Prompting Tips:

• Provide Context
• Proivde example
• Specifying output constraints
• Breakdown complex tasks
• Give the AI space to think.
• Define role

We can ask AI to frame an effective prompt. We can use that prompt.

Discernment:

It is evaluating what we receive from LLM, whether it meets our needs or not.

There are three kinds of discrement:

1. Product discernment — Evaluating the quality of AI Output
2. Process discernment — Assessing how AI approach the task
3. Performance discernment — Evaluating how AI behaved during the interaction itself.

Diligence:

It focuses mostly on ethics and safety aspects. There are three kinds of diligence.

1. Creation Diligence — We should be thoughtful about which AI systems we use and how we engage with them.
2. Transparency Diligence — We should be aware of AI’s role in our work
3. Deployment Diligence — We should take ownership of AI-assisted outputs we share with others.

If we consider these four competencies when we interact with LLM, we can get the best results from it, and we should be aware of its capabilities and limitations.

Thank you for reading. Have a nice day!

Reference Link

https://anthropic.skilljar.com/ai-fluency-framework-foundations

This post is an extension of the previous blog — how to create and publish web components in the npm registry. Click here to read.

Why do we need a storybook?

Over the years, frontend development has become complicated. There are many things a frontend developer needs to consider while developing a frontend application — Responsive design, different browsers support, application local state management, accessibility, and performance.

The modern JavaScript libraries and frameworks follow a component-driven approach (React, Angular, etc). In the component-driven approach, it breaks down complex UI into small, maintainable components.

But, there is a caveat in this approach, as the application grows, a number of components also grow. It becomes unmaintainable, and if we want to test the component, we need to run the application and go to a particular page and test it. It is a complicated work over time.

Storybook solves those problems — it isolates UI, now every piece of UI is a component, it provides a separate interface to render UI components, and we do not need to run the overall application.

As we render our component separately by storybook, we can change various props, mock data and fake events to know how our component works.

Storybook automatically generate documentation for each component. It provides testing features to write test cases and test components.

Storybook is packaged as a small, development-only, workshop that lives alongside your app. It provides an isolated iframe to render components without interference from app business logic and context. That helps you focus development on each variation of a component, even the hard-to-reach edge cases.

How do we add a story to our web component project?

I already created a web component project using Vite.

You can access the repo here and clone it, then do the following steps to set up Storybook.

After cloning the project and move to the project folder.

Install Storybook and initialise

$ npx storybook@latest init

The above command installs the required dependencies and init makes changes in the project folder. It added .storybook and stories folder.

.storybook — The folder contains all the configuration details of the storybook.

stories — Where we write stories for each UI component. This folder comes pre-defined UI and their stories. It should look like the screenshot below.

Run the storybook

$ npm run storybook

It will open the http://localhost:6006/ URL in our browser, where we find the UI description and the playground for our UI Components. We can play around with it.

We can remove unwanted UI and their stories.

Write a storybook for our web component

import { LitElement, html, css } from 'lit';
import { customElement, property, state } from 'lit/decorators.js';
import { classMap } from 'lit/directives/class-map.js';

@customElement('word-viewer')
export class WordView extends LitElement {
  static styles = css`
    :host {
      color: black;
      font-size: 30px;
      cursor: pointer;
      padding 2rem;
      display: inline-block;
    }

    pre{
     background: white;
     padding: 0.2rem;
    }
  `;

  @state() private idx = 0;

  @state() private playDirection = 1;

  @property() words: string = '';

  private intervalTimer?: number;

  override connectedCallback() {
    super.connectedCallback();
    this.intervalTimer = setInterval(() => {
      this.tickToNextWord();
    }, 1000);
  }

  override disconnectedCallback() {
    super.disconnectedCallback();
    clearInterval(this.intervalTimer);
    this.intervalTimer = undefined;
  }

  render() {
    const splitedWords = this.words.split(' ');
    return html`<pre
      @click=${this.switchPlayDirection}
      class="${classMap({ backwards: this.playDirection === -1 })}"
    >
    ${splitedWords[
        ((this.idx % splitedWords.length) + splitedWords.length) %
          splitedWords.length
      ]}
    </pre
    >`;
  }

  tickToNextWord() {
    this.idx += this.playDirection;
  }

  switchPlayDirection() {
    this.playDirection *= -1;
  }
}

declare global {
  interface HTMLElementTagNameMap {
    'word-viewer': WordView;
  }
}

The above example is for showing words one after another in the browser. I explained the details of the code here if you need to read it.

Now, create a file name word-viewer.stories.ts under the stories folder.

Import the below required plugin into the file.

import type { Meta, StoryObj } from '@storybook/web-components-vite';
import {WordView} from '../components/word-viewer';

Create an meta object which is for the UI documentation details — We configure it.

const meta = {
  title: 'Example/WordViewer',
  tags: ['autodocs'],
  component: 'word-viewer'
} satisfies Meta<WordView>;

export default meta;

If you want to know what Typescript satisfies is read it here.

The meta object should be the default export of our story file.

type Story = StoryObj<WordView>;

The above line creates a story object that contains details on how to render a story.

export const Default: Story = {
  args: {
    words: 'Hello, World!'
  }
};

export const Custom: Story = {
    args: {
      words: 'I am a custom word viewer!'
    }
  };

The above code has two stories, Default and Custom — Each one has its own values for props. The above one is minimal, we can do plenty of things with a Story.

Output:

Now, you can see the storybook output for the worldview component. You can see the Default and Custom stories with their arguments.

Thank you for reading. Have a nice day!

Reference link:

Source code: https://github.com/EdisonDevadoss/lit-webcomponent-tutorial/tree/configure-storybook

• How to Use the TypeScript satisfies Operator
• How to write stories | Storybook docs
• Writing stories in TypeScript | Storybook docs

What is a web component?

It is creating new reusable and encapsulated HTML tags using the custom elements API in HTML. The newly created tags have their functionality and behaviour.

We can relate this to Bootstrap or Material UI library — We can access reusable buttons, input boxes, etc..

Once we build our web components, we can publish them in the npm registry. Then, we can use it in all the projects.

Web component development

There are two ways we can create a web component,

1. create it from HTMLElement — Vanilla approach
2. create it from a third-party library like lit, stenciljs

Create it from HTMLElement

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Document</title>
  </head>
  <body>
    <style>
      lut-button {
        background-color: red;
        padding: 20px;
      }
    </style>
    <lut-button>Hello</lut-button>
    <script>
      class LutButton extends HTMLElement {
        constructor() {
          super();

          this.addEventListener('click', () => {
            console.log('cliked');
          });
        }
      }

      customElements.define('lut-button', LutButton);
    </script>
  </body>
</html>

If you look at the above code, I have created a new tag <lut-button> using the JavaScript class method. Here I have defined a class LutButton that extends from HTMLElement, and I have added an event listener inside the constructor, which listens whenever LutButton is clicked.

You can see the output in the above screenshot.

The above one is just a Hello World of web component creation using HTMLElement. HTMLElement has more features. An important one is the Lifecycle callback.

Lifecycle callbacks:

There are three lifecycle callbacks we should know.

1. connectedCallback — called each time the element is added to the document.
2. disconnectedCallback — called each time the element is removed from the document
3. attributeChangedCallback — Called when attributes are changed, added, removed, or replaced.

Let's move to another way of building web components — using a third-party library.

Web component using Lit:

$ npm create vite@latest

In the above image, you can see the option selected. We have to choose Lit as a selected framework.

$ cd web-component
$ code .

You can see the above folders and files of the project. Application starts from the index.html file, where we imported <my-element>.

Now we can create a new Element — create a new file named word-viewer.ts under the src folder.

import { LitElement, html, css } from 'lit';
import { customElement, property, state } from 'lit/decorators.js';
import { classMap } from 'lit/directives/class-map.js';

@customElement('word-viewer')
export class WordView extends LitElement {
  static styles = css`
    :host {
      color: violet;
      cursor: pointer;
      padding 2rem;
      display: block;
    }

    pre{
     background: white;
     padding: 0.2rem;
    }
  `;

  @state() private idx = 0;

  @state() private playDirection = 1;

  @property() words: string = '';

  private intervalTimer?: number;

  override connectedCallback() {
    super.connectedCallback();
    this.intervalTimer = setInterval(() => {
      this.tickToNextWord();
    }, 1000);
  }

  override disconnectedCallback() {
    super.disconnectedCallback();
    clearInterval(this.intervalTimer);
    this.intervalTimer = undefined;
  }

  render() {
    const splitedWords = this.words.split(' ');
    return html`<pre
      @click=${this.switchPlayDirection}
      class="${classMap({ backwards: this.playDirection === -1 })}"
    >
    ${splitedWords[
        ((this.idx % splitedWords.length) + splitedWords.length) %
          splitedWords.length
      ]}
    </pre
    >`;
  }

  tickToNextWord() {
    this.idx += this.playDirection;
  }

  switchPlayDirection() {
    this.playDirection *= -1;
  }
}

declare global {
  interface HTMLElementTagNameMap {
    'word-viewer': WordView;
  }
}

Look at the above example, WordView class extends from LitElement. LitElement is a wrapper of the HTMLElement.

We can access the WordView element in the HTML file.

<!doctype html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Vite + Lit + TS</title>

    <script type="module" src="/src/word-viewer.ts"></script> 
  </head>
  <body>

    <word-viewer words="I am Edison Devadoss"></word-viewer>

  </body>
</html>

Using @customElement(‘word-viewer’) , We can define a tag name.

Using @property() words: string = ‘’; We can dynamically pass a value from outside the component. Trigger components when updated.

Using @state() private idx = 0; We can update the state internally. It can not be accessed outside the component.

private intervalTimer?: number;

 override connectedCallback() {
    super.connectedCallback();
    this.intervalTimer = setInterval(() => {
      this.tickToNextWord();
    }, 1000);
  }

  override disconnectedCallback() {
    super.disconnectedCallback();
    clearInterval(this.intervalTimer);
    this.intervalTimer = undefined;
  }

Look at the above code — These are lifecycle callbacks, connectedCallback is called when an element is added, and disconnectedCallback is called when the component is removed. Using these lifecycle callbacks, we initiated a time interval.

The above example is for showing words one after another.

Run the above code

$ npm run dev

Now we see the output in the browser using accessing http://localhost:5173/.

Publish library in the npm registry.

To publish our web component to npm, we need to create a build first. Before that, we need to define the npm version in the package.json file.

{
  "name": "word-viewer",
  "private": false,
  "version": "0.1.4",
  "main": "dist/word-viewer.es.js",
  "exports": {
    ".": "./dist/word-viewer.es.js"
  },
  "types": "dist/word-viewer.d.ts",
  "files": [
    "dist",
    "types"
  ],
  "scripts": {
    "dev": "vite",
    "build": "tsc && vite build",
    "preview": "vite preview"
  },
  "dependencies": {
    "lit": "^3.3.0"
  },
  "devDependencies": {
    "typescript": "~5.8.3",
    "vite": "^6.3.5",
    "vite-plugin-dts": "^4.5.4"
  }
}

The above code is my package.json file. Here I change the given version, we can start from 0.1.0.

“main”: “dist/word-viewer.es.js” — Where we start our code execution.

"exports": {
    ".": "./dist/word-viewer.es.js"
  },

The above one is what we are exporting code, it tells which part of the code is publicly available.

“types”: “dist/word-viewer.d.ts” — It has a type definition

“files”: [ “dist”] — It has what is published when it pushes it to the npm registry.

We have to add a README.md file where we have to mention the installation steps for our package.

Now, we can build our application.

$ npm run build

Now you see a folder name dist where you can find files.

Npm Signup

Create an account in npm by clicking here

After the signup is completed, we log into npm in our terminal.

$ npm login

The above command will open a login link in the browser where we need to give our username and password.

Once npm is published, run the following command. It takes a few seconds to publish our npm.

$ npm publish

Once the above command is executed, we can see the package in the npm registry.

You can see my published package in the link below.

word-viewer

Now we can use this package everywhere. I have mentioned how to use it in a React application in this package.

Thank you for reading. Have a nice day!

Reference links:

Code (Create Web component using HTMLElement): https://github.com/EdisonDevadoss/webcomponent-project

https://github.com/EdisonDevadoss/lit-webcomponent-tutorial

Set up an account in Google APIS.

Click the link and set up a Google account, then access the API services.

Then search in the service bar “calendar” and enable the calendar API. Consider the image below as a reference.

After the calendar is enabled, configure the authorised redirect URI for authorisation.

Once authorised with our Google account, it will redirect to the configured URL and give an access code. We need this access code for Google Calendar booking.

Define the Auth callback

import Fastify from 'fastify';

const fastify = Fastify({
  logger: true
});

// Declare a route
fastify.get('/auth', async function handler(request, reply) {
  console.log('request', request);
  return { hello: request.query };
});

try {
  await fastify.listen({ port: 3000 });
} catch (err) {
  fastify.log.error(err);
  process.exit(1);
}

The above code is just a Fastify application setup and configured with one route with the GET method. In request.query We can find the access code.

$ node server.js

Now we can run the application using the above command.

Generate Gemini API

Once the Google API is configured now we can generate the Gemini API key and configuration.

Click this link to generate an API key. After generating of API key, configure it in the .env file.

GEMINI_API_KEY=

Not only the Gemini API key, but we can also configure the following in .env

GOOGLE_CLIENT_ID=''
GOOGLE_CLIENT_SECRET=''
REDIRECT_URI=''

Install the required library in our application.

$ npm install @google/genai dotenv fastify googleapis --save

Run the above command to install all required libraries.

Create aindex.js file where we can write our code for calendar booking.

import { configDotenv } from 'dotenv';
configDotenv();

import { GoogleGenAI, FunctionCallingConfigMode } from '@google/genai';
import { google } from 'googleapis';
import * as readline from 'readline';

const { GEMINI_API_KEY, GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET, REDIRECT_URI } =
  process.env;

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

const genAI = new GoogleGenAI({ apiKey: GEMINI_API_KEY });
const geminiModel = genAI.models;

const oauth2Client = new google.auth.OAuth2(
  GOOGLE_CLIENT_ID,
  GOOGLE_CLIENT_SECRET,
  REDIRECT_URI
);

In the above, we import the library needed for the application and initialise the GoogleGenAI model and the oauthClient library.

We have used it readline for interaction with the node application via the terminal.

async function authenticate() {
  const authUrl = oauth2Client.generateAuthUrl({
    access_type: 'offline',
    scope: 'https://www.googleapis.com/auth/calendar.events'
  });
  console.log('Authorize this app by visiting this url:', authUrl);
  rl.question('Enter the code from that page here: ', async (code) => {
    try {
      const tokenResponse = await oauth2Client.getToken(code);
      tokens = tokenResponse.tokens;
      oauth2Client.setCredentials(tokens);
      calendar = google.calendar({ version: 'v3', auth: oauth2Client });
      console.log('Authentication successful!');
      queryGemini();
    } catch (err) {
      console.error('Error retrieving access token', err);
      rl.close();
    }
  });
}

The above function is for authentication with the Google API for calendar access.

rl.question It asks for our input via the terminal. Once we are authorised using authUrl, we can enter the code in our terminal or paste it.

This function generates a token for our further access. Then it will call queryGemini() function.

const chatHistory = [];

let isBooked = false;


async function queryGemini() {
  rl.question('Ask Gemini (or say "book calendar"): ', async (query) => {
    try {
      chatHistory.push({
        role: 'user',
        parts: [{ text: query }]
      });

      const result = await geminiModel.generateContent({
        model: 'gemini-2.0-flash-001',
        contents: chatHistory,
        config: {
          systemInstruction: `
You are a smart assistant that helps users with any kind of query.

If the user explicitly says they want to book a calendar, schedule a meeting, or talk to an agent, interpret it as a request to create a calendar event and use the \`create_calendar_event\` function (if enough information is available). Ask only the necessary missing details.

Once the calendar event is successfully created, return to normal assistant behavior. Do not continue suggesting or prompting about calendar bookings unless the user explicitly brings it up again.

For all other types of queries, respond normally as a helpful assistant.
`,
          toolConfig: {
            functionCallingConfig: {
              mode: FunctionCallingConfigMode.AUTO
            }
          },
          tools: tools
        }
      });

      const response = result;

      console.log('Gemini:', response.text);

      if (!isBooked && response.functionCalls?.length > 0) {
        const func = response.functionCalls[0];
        console.log('Function call received:');
        console.log('Function name:', func.name);
        console.log('Arguments:', func.args);
        const args = func.args;

        if (func.name === 'create_calendar_event') {
          await bookAEvent(
            args.title,
            args.date,
            args.time,
            args.email,
            args.timezone
          );
          isBooked = true;
        }
      } else if (response.text) {
        chatHistory.push({
          role: 'model',
          parts: [{ text: result.text }]
        });
      }
    } catch (error) {
      console.error('Error querying Gemini:', error);
    }
    queryGemini(); // Continue the REPL
  });
}

In the above code, using geminiModel.generateContent() We can interact with our Gemini LLM.

There are a few more things we configured with the generateContent method.

1. model — AI model name with version
2. contents — we are passing chat history — both user input and model response. We store those values chatHistory array.
3. config — In the config, we set up system instruction, toolConfig, and tools.
4. systemInstruction — It is a prompt message on how our system should act.

If you look at the system instructions, we mentioned the call create_calander_event function if the user requests a book an event or talk to an agent.

     toolConfig: {
            functionCallingConfig: {
              mode: FunctionCallingConfigMode.AUTO
            }

The above configuration defines the mode of function call, it can be AUTO or ANY.

If we set ANY it will call the time user chats, it AUTO means once matched with the system instruction.

Define the create calendar event function

onst tools = [
  {
    functionDeclarations: [
      {
        name: 'create_calendar_event',
        description: 'Create a calendar event based on user input.',
        parameters: {
          type: 'object',
          properties: {
            title: {
              type: 'string',
              description: 'The title of the event'
            },
            email: {
              type: 'string',
              description: "User's email of the event (e.g., edison@yavar.ai)"
            },
            date: {
              type: 'string',
              description: 'The date of the event (e.g., 2025-05-10)'
            },
            time: {
              type: 'string',
              description: 'The time of the event (e.g., 3:00 PM)'
            },
            timezone: {
              type: 'string',
              description:
                'The timezone of the event (e.g., Asia/Kolkata, America/New_York)'
            }
          },
          required: ['title', 'email', 'date', 'time', 'timezone']
        }
      }
    ]
  }
];

Using the above code, we defined functionDeclarations and set up a function named create_calendar_event and defined what the inputs are that we need to collect from the user for calendar booking.

Once the user enters the required fields for calendar booking, we can find values in response.functionCalls.

 if (response.functionCalls?.length > 0) {
      const func = response.functionCalls[0];
   console.log('func is', func);
   console.log('Function name:', func.name);
   console.log('Arguments:', func.args);
    const args = func.args;

  
   if (func.name === 'create_calendar_event') {
          await bookAEvent(
            args.title,
            args.date,
            args.time,
            args.email,
            args.timezone
          );
          isBooked = true;
        }
      } 
}

Now you can find values in the logs and call bookAEvent function.

async function bookAEvent(title, date, time, mail, timezone) {
  const startDateTime = new Date(`${date} ${time}`);
  const endDateTime = new Date(startDateTime.getTime() + 60 * 60 * 1000); // +1 hour

  const event = {
    summary: title, 
    start: {
      dateTime: startDateTime.toISOString(), 
      timeZone: timezone
    },
    end: {
      dateTime: endDateTime.toISOString(),
      timeZone: timezone
    },
    attendees: [
      { email: 'edisonj1996@gmail.com' },
      { email: mail }
      // Replace with extracted attendees
    ],
    conferenceData: {
      createRequest: {
        requestId: 'meet-' + Date.now(),
        conferenceSolutionKey: {
          type: 'hangoutsMeet'
        }
      }
    }
  };
  console.log('evet is', event);

  if (calendar) {
    const calendarResponse = await calendar.events.insert({
      calendarId: 'primary', // Use 'primary' for the user's main calendar
      auth: oauth2Client,      resource: event,
      conferenceDataVersion: 1
    });
    // console.log('bookAEvent is', calendarResponse);
  }
}

The above function is for creating an event in the calendar. We need to pass the following details in the resource.

1. summary — event tittle
2. start — start time with timezone
3. end—end time with timezone
4. attendees — email of all attendees.
5. confererceData — it is for generating a g-meet link

Now, calling node index.jsWe can run the application and chat with Gemini, and book an event in Google Calendar.

References:

Access full code — https://github.com/EdisonDevadoss/gemini-calendar-booking-node-example/tree/main

Google APIs — https://console.cloud.google.com/apis

Gemini API key — https://aistudio.google.com/apikey

Thank you for reading. Have a nice day!

Book a Google calendar by using Gemini LLM was originally published in YavarTechWorks on Medium, where people are continuing the conversation by highlighting and responding to this story.

What is docker

The official document explanation is as follows:

Accelerate how you build, share, and run applications. Docker helps developers build, share, run, and verify applications anywhere — without tedious environment configuration or management.

I will define what strikes in my heart after learning and working with docker.

It makes our application platform agnostic. Our application is no longer embedded with the platform(run-time), configurations and other dependencies. It gives us a lot of flexibility when running our application.

By using docker, we can package our app and running environment as a single container, and that container can also be distributed.

What problem does docker solve?

Docker gives one isolated environment to run the app.

It is easy to run different versions of services on the same machine.

We should be familiar with a few important docker concepts. I will explain them as follows:

Docker Image

It is a standalone executable of the software that includes everything needed to run the application (code, configuration, Run time, etc)

Container:

It is running an instance of a docker image. The Docker container runs in the Docker engine.

Dockerfile:

If we want to dockerize our application, we need a Dockerfile in our project — it should have instructions to build docker images.

Repository:

Collection of container images or versions of an application stored within a registry. Registry has multiple repositories — Docker hub is the public registry.

Run a docker service:

To run a docker service, we should be familiar with a few comments.

Check existing running docker container:

$ docker ps

docker ps command gives details of running containers on my machine.

How to run a new service:

There are plenty of open-source services available in the Docker hub where we can find a service and run it on our machine.

Now, I will run an Nginx service on my machine using docker. You can find the Nginx docker service here.

First, we have to pull the Nginx service image in our local machine. To do this, we have to use the below command.

$ docker pull nginx:latest

Using the tag :latest we can pull the latest version of the service. Instead of this we can give our perferfable version also.

The above command will download a new nginx service image.

$ docker images

The above command is for checking existing images.

In the above image, we can newly download the nginx docker image.

Run a docker image

To run a docker image, we have to use the below command

$ docker run ngnix

In the above command, we have to give the docker image name. In my case, it is Nginx.

You can see docker running logs.

Now, we can access the newly created docker image instance(Container).

To run http://localhost:80 in the browser, we can access the application.

But, by clicking ctrl+c we can close the application, after that we can not access the service in the browser.

To fix this, we have run the service in the detach mode.

$ docker run -d nginx

By using -d in the option, we can run the application in the background mode.

Now, we can find the nginx container in the list of running containers.

In the above image, you can see Nginx as an actively running container.

Stop a Container

To stop a container, we have to give the command docker stop <Container ID>.

$ docker stop 0b652d49e264

After the container is stopped, it will not be present when we run the docker ps command.

If we want to see all the containers, including stopped containers, we can give the below command.

$ docker ps -a

At this juncture, I conclude this post. I hope I will write more posts about docker.

Not but not least, Docker is a vast subject to learn, and its use cases also border. To know further refer docker official document.

Thank you for reading. Have a nice day!

My Understanding of Docker was originally published in YavarTechWorks on Medium, where people are continuing the conversation by highlighting and responding to this story.

Hi friends, in this post I will share how to use multiple git accounts on our machine.

I hope, most of the developers are like me to have their own GitHub account and their company's git account.

By default, we can configure our system or laptop with only one git account. So whenever we are working with repositories under that git account we do not need to give a username and password Token for each git operation — git pull, push, fetch.

But sometimes we may need to work on repositories which are in other git providers such gitlab or Azure Git. In that case, we need to give a git username and password for every git operation (Communicating with git cloud).

To avoid giving username and password tokens for every git operation, we can configure username and password tokens with those repositories.

Git Configuration with the project Repo

Here, I have a GitHub repository that is connected to my personal GitHub account, but my system does not configure my personal GitHub account. So I can not use the SSH method to add a remote URL in the the project folder. So I need to use the HTTPS method to add a remote URL in the project folder.

If I want to push my code, it will ask username and password. You can see this in the above image.

By entering my username and password, I can push my code. Here, I need to do this for every push, pull, and fetch operation. Is it not redundant work?

How do we avoid the repetition?

1. Open the git config file of the project

vim .git/cofig

It will open the following file. Here I added a Username and Password.

2. Here we need to add Username and Password.

    url = https://github.com/EdisonDevadoss/javascript-problem-solving.git

By default it shows like this above, we need to add <Username>: and <Password>

Then save the file. Now run the git push command.

Now It will not ask us to enter a username and password for any git operation.

I hope this tip is helpful.

Thank you for reading. Have a nice day!

Handle Multiple git accounts in a system was originally published in YavarTechWorks on Medium, where people are continuing the conversation by highlighting and responding to this story.

Hi friends, I would like to give my insights about the book Same as Ever by Morgen Housel.

We often hear the quote “Only things never change is everything changes” But there are certain things in the world that never be changed by the time. Examples: Human behaviour, greed, emotions, uncertainties in the world, etc.

Morgen Housel presented twenty-three Same as Ever chapters. I want to share a few of the concepts which inspired me.

Hanging by a Thread

If you know where we have been, you realize we have no idea where we are going.

Our lives and history are often shaped by random events which are completely out of our control.

During World War I, one of the American steamships was travelling from New York to Liverpool. The ship's captain shut down the fourth boiler to save money. But this decision would slow the ships’ voyage by one day.

Because of this delay, the American ship and German submarine sailed the same path and finally, the German submarine hit the American ship and twelve hundred passengers were killed.

This incident was the most important trigger for getting the public opinion of America to enter World War I.

If the fourth boiler had not shut down, the American ship would have been reached one day before it met the German submarine and they could have avoided World War I.

You can play this game all day. Every big story could have turned out differently if a few little puffs of nothingness had gone the other direction.

Every current event — Big or Small — has parents, grandparents, great-grandparents, siblings and cousins. Ignoring that family tree can muddy our understanding of events, giving a false impression of why things happened, how long they might last, and under what circumstances they might occur again.

People like to say, To know where we are going, you have to know where we have been. But more realistic is admitting that if you know where we have been, you realize we have no idea where we are going.

The second un-changeable rule is, “Expectations and Reality”.

Expectations and Reality

Once ninety-eight-year-old Chalie Munger was asked, You seem extremely happy and content. What is your secret to living a happy life? Munger replied:- The first rule of a happy life is low expectations. If you have unrealistic expectations you are going to be miserable your whole life. You want to have reasonable expectations and take life’s results, good and bad as they happen with a certain amount of stoicism.

Your happiness depends on your expectations more than anything else. So in a world that tends to get better for most people most of the time, an important life skill is getting the goalpost to stop moving. It is also one the the hardest.

The quality of life goes up, and people’s expectations also rise. Because those improvements also benefit other people around us, whose circumstances we anchor to.

Montesquieu wrote Two hundred and seventy-five years ago, “If you only wished to be happy, this could be easily accomplished; but we wish to be happier than other people and this is always difficult, for we believe others to be happier than they are”.

The third un-changeable rule is “The Best story wins”.

The Best story wins

Martin Luther King Jr.’s famous speech at the Lincoln Memorial on August 28, 1968, did not go according to plan.

King’s advisor and speechwriter, Clarence Jones, drafted a full speech for King to deliver, and based on that he started to deliver his speech.

The first few minutes of the king’s speech followed the script. The video shows him constantly looking down at his notes, and reading the script.

Just then, around halfway through the speech, gospel singer Mahalia Jackson — who was standing to kings’ left, maybe ten feet away. She shouted out “Tell them about the dream, Martin! Tell them about the dream!”

Then Martin, put aside his notes, grabs the lectern and looks out on more than 250,000 people. He took a six-second pause and said:

I have a dream. It is a dream deeply rooted in the American dream.

I have a dream that one day this nation will rise up and live out the true meaning of its creed: “We hold these truths to be self-evident, that all men are created equal”.

I have a dream that my four little children will one day live in a nation where they will not be judged by the colour of their skin but by the content of their character.

I have a dream today.

The rest is history. That portion of the speech which is most celebrated around the world is not the speech that he planned to give. King did not prepare this speech.

But this was one of the best stories ever told, evoking emotion and connecting the dots in millions of people’s heads in a way that changed history.

Sapiens is a famous book, by the author Yuval Noah Harari. He became a bestselling contemporary author.

He once agreed I did zero new research. I just read the kind of common knowledge and just presenting it in a new way. Sapiens is famous because of its beautiful writing. The best story wins.

Often, It is not what you say, but how you say it. That matters.

Not only these three chapters, I like all the 23 chapters in the book. If you have the habit of underlining the book, you will find something on every page to underline.

This is the one of best books I read this year.

Thank you for reading. Have a nice day!