DEV Community: Jotty John

RAG Architecture

Jotty John — Thu, 26 Mar 2026 11:38:22 +0000

RAG stands for Retrieval-Augmented Generation — a technique used in AI to give more accurate and up-to-date answers.

Instead of the AI only using what it already “knows”
It first searches for relevant information
Then uses that information to generate a better answer

You can build a RAG app by combining 3 core pieces:

Store knowledge from your documents in a searchable form
Retrieve relevant chunks for a user question
Ask an LLM to answer using only that retrieved context

Think of it as: search first, generate second. The model gets smarter for your data without retraining—very budget-friendly, very civilized.

What a RAG app needs

A typical RAG pipeline looks like this:

The basic architecture

1) Data ingestion

Load your source data:

PDFs
Word docs
Markdown files
HTML/web pages
database records
internal knowledge base

2) Chunking

Split large documents into smaller passages, for example:

300–800 tokens per chunk
some overlap, like 50–100 tokens

Why? Because embedding and retrieval work better on focused pieces of text.

3) Embeddings

Convert each chunk into a numeric vector using an embedding model.

Examples:

OpenAI embeddings
sentence-transformers
Cohere embeddings
Voyage AI embeddings

4) Vector database

Store the embeddings and original text.

Popular options:

Chroma: easiest for local prototypes
FAISS: very fast local similarity search
Pinecone: managed hosted service
Weaviate
Qdrant
Milvus

5) Retriever

When the user asks a question:

embed the question
search the vector DB for top-k similar chunks
optionally rerank them

6) Generation

Send the retrieved chunks + question to the LLM with a prompt like:

Answer using only the provided context. If the answer is not in the context, say you don’t know.

That reduces hallucinations a lot.

Easiest stack for a first RAG app

If you want the fastest path, I’d suggest:

Python
FastAPI or Streamlit
LangChain or LlamaIndex
Chroma for local vector storage
OpenAI or another chat model

That’s a very beginner-friendly setup.

Minimal build plan

Option A: super simple prototype

Use:

Python
Streamlit
Chroma
OpenAI API

Good for:

uploading docs
asking questions in a browser UI
learning the flow

Option B: production-ish starter

Use:

FastAPI backend
React/Next.js frontend
Qdrant or Pinecone
background ingestion jobs
auth + logging + evaluation

Good for:

team/internal tool
customer-facing app
scaling beyond hobby level

A simple MVP flow

Step 1: install packages

For a simple Python version, you’d usually need packages like:

langchain
chromadb
openai
pypdf
tiktoken
streamlit

Step 2: load documents

Read your files from a folder like data/.

Step 3: split into chunks

Use a text splitter with overlap.

Step 4: create embeddings

Generate embeddings for each chunk.

Step 5: store them in Chroma

Persist the vector store locally.

Step 6: build a query function

Take a user question, retrieve top matches, and send them to the model.

Step 7: add a UI

A simple chat box is enough for v1.

Tiny example in Python

Here’s the shape of a minimal RAG script:

from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import Chroma
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import PyPDFLoader
from langchain.chains import RetrievalQA

# 1. Load document
loader = PyPDFLoader("docs/manual.pdf")
docs = loader.load()

# 2. Split into chunks
splitter = RecursiveCharacterTextSplitter(
    chunk_size=800,
    chunk_overlap=100
)
chunks = splitter.split_documents(docs)

# 3. Embed + store
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_db"
)

# 4. Retriever
retriever = vectorstore.as_retriever(search_kwargs={"k": 4})

# 5. LLM
llm = ChatOpenAI(model="gpt-4o-mini")

# 6. QA chain
qa = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=retriever
)

# 7. Ask a question
query = "How do I reset the device?"
answer = qa.run(query)
print(answer)

That’s the basic idea. Real apps add citations, source display, better prompts, and error handling.

What makes a RAG app actually good

A lot of RAG apps work, but only a few work well. The difference usually comes from these:

Better chunking

Bad chunks = bad retrieval.

Tips:

keep sections semantically meaningful
don’t split tables badly
preserve headings/metadata
include source info like filename and page number

Metadata filtering

Store metadata such as:

file name
page number
department
date
access level

Then retrieve with filters, like:

only HR docs
only 2025 policies
only docs user is allowed to see

Hybrid search

Use:

vector search + keyword search

This helps when users ask for:

exact product codes
error IDs
names/acronyms

Reranking

After getting top 10 chunks, rerank them with a stronger relevance model and keep top 3–5.

This often improves quality a lot.

Grounded prompting

Use prompts that force the model to stay within context and cite sources.

Example:

answer only from context
quote source passages when possible
say “I don’t know” if unsupported

Citations

Show users where the answer came from:

file name
page number
snippet preview

This builds trust and makes debugging much easier.

Common mistakes

1) Chunks are too large

If chunks are giant, retrieval gets fuzzy.

2) No overlap

Then important context gets chopped in half like an unfortunate sandwich.

3) Bad PDFs

Some PDFs extract terribly. You may need OCR or better parsing.

4) No evaluation

If you don’t test retrieval quality, you won’t know whether the issue is:

retrieval
prompt
model
data quality

5) Letting the model answer without guardrails

Always tell it to use only retrieved context.

How to evaluate your RAG app

You should test 3 things separately:

Retrieval quality

Ask:

Did the right chunks come back?
Was the right answer present in retrieved docs?

Answer quality

Ask:

Is the answer accurate?
Is it complete?
Does it cite sources?

Latency/cost

Track:

embedding cost
retrieval speed
generation speed
token usage

A very practical evaluation set is:

20–50 real user questions
expected source documents
expected answer points

Good first project ideas

Start with one of these:

PDF question-answering app
Company handbook assistant
Support docs chatbot
Course notes tutor
Codebase documentation assistant

For a first build, I’d recommend:

upload PDFs
ask questions
show citations
keep everything local except the model API

That’s enough to learn the full RAG loop.

If you want a production-ready design

A more serious app usually has:

Ingestion service
Embedding/index pipeline
Vector DB
Chat backend
Frontend
Evaluation dashboard
User auth
Document permissions
Observability/logging

A common production flow:

user uploads document
backend extracts text
text is chunked and embedded
vectors stored with metadata
chat query retrieves relevant chunks
model answers with citations
logs stored for debugging and eval

Best beginner recommendation

If you want the shortest path, do this:

Python
Streamlit
LangChain
Chroma
OpenAI API
local folder of PDFs

That lets you learn:

ingestion
chunking
embeddings
retrieval
prompting
UI

Use Cases
RAG is an effective solution for business scenarios that involve large volumes of documentation and complex rules, where users need reliable and authoritative answers. It is particularly well-suited for enhancing LLM-based chatbots by incorporating proprietary or domain-specific knowledge, while significantly reducing the risk of hallucinations.

Happy to share in the current era of AI and Zero Carbonization

Jotty John — Tue, 14 Oct 2025 08:13:48 +0000

Harnessing AI for Zero Carbonization: Innovations and Impacts

Jotty John ・ Jun 19 '24

#ai

Is my phone eavesdropping on me?

Jotty John — Mon, 04 Aug 2025 08:12:33 +0000

Is My Phone Eavesdropping on Me?
How Can We Use Smartphones Wisely?

Almost every person — regardless of age, profession, or location — uses a smartphone. Concerns about privacy, data tracking, and screen addiction affect all of us. I think this is a good topic for discussion..

Bridging the Gender Gap in STEM — One Step at a Time

Jotty John — Mon, 04 Aug 2025 08:07:33 +0000

STEM — science, technology, engineering, and math — is changing the world we live in. From building apps and curing diseases to solving climate issues and sending rockets into space, STEM is where the future is being shaped. But here’s the thing: women are still hugely underrepresented in these fields.

So, what’s holding us back? And more importantly, what can we do about it?

Let’s Start with the Facts
Women make up less than 30% of the global STEM workforce.

In areas like AI, cybersecurity, and system design, the number of women is even lower — sometimes under 15%.

Many girls lose interest in STEM subjects by the time they reach high school, often because they don’t see enough role models who look like them or because they’re told — subtly or directly — that it’s “not for them.”

This gender gap isn't just a diversity problem — it's a missed opportunity. When women aren’t fully part of STEM, the solutions being built don’t reflect the full range of human needs or perspectives.

Why Is There Still a Gap?
The reasons are many — and layered:

Stereotypes: From an early age, girls are often told (directly or indirectly) that STEM is “hard” or “not for girls.”

Lack of role models: If you can’t see it, it’s hard to believe you can be it.

Workplace culture: Many women who enter STEM fields leave mid-career because the environment isn’t always welcoming or flexible.

Balancing life and work: Without supportive policies, many women struggle to juggle caregiving responsibilities with demanding STEM careers.

So, How Do We Bridge This Gap?
The good news? Change is happening — and we can all be part of it.

Start Early We need to spark curiosity in STEM from a young age — through fun, hands-on activities, coding clubs, science experiments, and storytelling. Let girls build, break, explore, and solve.

“I didn’t know tech was for me until someone handed me a Raspberry Pi and told me to make it talk.” — A story we hear too often, too late.

Show Real Role Models
We need to put more women in STEM in the spotlight — on panels, in textbooks, in classrooms, on social media. Young girls (and even grown women!) need to see that being a scientist, developer, engineer, or mathematician isn’t just possible — it’s happening right now.
Make Workplaces More Inclusive
Companies and institutions must take real steps — not just posters and hashtags — to make STEM careers more inclusive. That means:

Fair hiring and promotions

Equal pay

Parental leave policies

Mentorship programs

Safe and respectful work environments

Support Women at Every Stage
It’s not just about getting more women into STEM — it’s about helping them stay and grow. Let’s normalize career breaks, offer returnships, and support flexible work. And most importantly, let’s listen to what women actually need in their careers.
Celebrate the Stories
Every woman in STEM has a story worth telling. Let’s celebrate the wins — big or small — and amplify these journeys. It inspires others and reminds us that we’re not alone.

Why This Matters for Everyone
Bridging the gender gap in STEM isn’t just about fairness. It’s about creating better solutions, stronger teams, and a more innovative world. We all benefit when more voices are included.

Imagine a world where:

AI is built with less bias

Medical research includes women’s health

Smart cities are designed by diverse minds

Girls grow up seeing STEM as an exciting, natural path for them

That’s the world we’re working toward.

Final Thoughts: Let’s Build the Bridge Together
There’s no quick fix to closing the gender gap in STEM, but every step counts — whether it’s encouraging a young girl to explore tech, mentoring a woman returning to work, or making room for new voices at the table.

We don’t have to wait for the world to change — we can start building it ourselves.

If you're a woman in STEM, keep going.
If you're not in STEM but care, support and speak up.
And if you're hiring, mentoring, or leading — lift as you climb.

The future of STEM is inclusive. Let’s build it together

How Spring Boot Application Works Internally?

Jotty John — Thu, 13 Feb 2025 08:34:14 +0000

Ever wonder what happens when we select 'Rua As' -> 'Spring Boot App'?
I always thought 'Wow!', SptingBoot is so simple. So what happens internally when we run a Spring Boot App from our IDE?

I found couple of interesting posts and it helped me understand the flow.
So thought of sharing for the people who are ingterested.

https://medium.com/@kkgsanjeewac77/curious-engineering-facts-spring-boot-internal-keycloak-january-release-27-25-c91a9ebba29f

https://www.php.cn/faq/537379.html

Hope its interesting for curious minds like me :)

[Boost]

Jotty John — Tue, 07 Jan 2025 13:56:57 +0000

Data-Driven Pattern

Jotty John ・ Jan 7

Data-Driven Pattern

Jotty John — Tue, 07 Jan 2025 13:52:25 +0000

Data-Driven Pattern: An In-Depth Look with Examples
The Data-Driven Pattern is an architectural style where the flow of data dictates the behavior of the system. This pattern emphasizes the centrality of data, focusing on its storage, processing, and retrieval. It is particularly suited for systems where data consistency, integrity, and complex queries are critical.

Key Components of a Data-Driven System
Data Source: Where data is generated or collected (e.g., sensors, user inputs).
Data Storage: Centralized databases or data warehouses.
Data Processing: Business logic that processes the stored data, often in batch mode.
Data Access Layer: Interfaces for accessing and manipulating the data (e.g., APIs, SQL queries).
Data Presentation: Dashboards or reports that display processed data to users.

Characteristics
Centralized Data Management: A single source of truth for data.
Complex Querying: Supports intricate data operations, often using SQL or similar querying languages.
Data Integrity and Consistency: Ensures that data remains consistent across the system.
Batch Processing: Data is processed in large batches, which may not be real-time but ensures thorough data integrity.

Examples of Data-Driven Pattern Applications
1. Enterprise Data Warehouse (EDW)
Use Case: A retail company wants to analyze sales trends across various regions.

Data Collection: Point of Sale (POS) systems collect transaction data.
Data Storage: The data is stored in a centralized data warehouse.
Data Processing: ETL (Extract, Transform, Load) processes clean and aggregate data into meaningful formats.
Data Access: Business intelligence tools like Tableau or Power BI query the data to generate reports.
Outcome: The company can analyze past sales data to make informed decisions about inventory and marketing strategies.

2. Customer Relationship Management (CRM) Systems
Use Case: A company wants to track customer interactions to improve service.
Data Collection: Customer interactions via emails, calls, and social media are logged.
Data Storage: All interactions are stored in a centralized CRM database.
Data Processing: The system processes the data to provide a unified view of customer interactions.
Data Access: Sales and support teams access the data through the CRM’s interface to understand customer needs.
Outcome: Improved customer service due to a comprehensive view of customer history.

3. Healthcare Records System
Use Case: A hospital wants to maintain detailed patient records.
Data Collection: Patient data is collected during consultations and treatments.
Data Storage: Data is stored in a centralized electronic health record (EHR) system.
Data Processing: The system processes data to flag potential health risks based on medical history.
Data Access: Healthcare professionals access patient records to provide informed care.
Outcome: Enhanced patient care due to readily available and accurate patient history.

Benefits of Data-Driven Pattern
Consistency: A centralized data repository ensures all users have access to the same data.
Complex Data Analysis: Enables detailed analytics and reporting, essential for data-driven decision-making.
Data Integrity: Centralized control helps maintain high data quality and integrity.

Challenges of Data-Driven Pattern
Scalability Issues: Centralized data storage can become a bottleneck as data volume grows.
Latency: Batch processing may lead to delays in data availability, making real-time decision-making challenging.
Complexity in Data Management: Managing a large, centralized data store requires sophisticated infrastructure and governance.

Example in a Real-World Scenario
Company: A large e-commerce platform.
Data Collection: Tracks customer purchases, returns, and website interactions.
Data Storage: Data is stored in a centralized data warehouse.
Data Processing: Processes data to identify trends such as popular products or customer churn rates.
Outcome: The company can offer personalized recommendations and improve customer retention by analyzing past behavior patterns.

In summary, the Data-Driven Pattern is ideal for applications that require detailed analysis and consistency in data handling, making it a cornerstone of systems where data is the lifeblood of operations.

The Role of Renewable Energy in Achieving Zero Carbon Societies

Jotty John — Mon, 16 Dec 2024 11:16:57 +0000

As the world grapples with the growing threat of climate change, the urgency of transitioning to zero-carbon societies has never been clearer. Central to this transition is the role of renewable energy. Renewable energy sources like solar, wind, hydropower, and geothermal are not just vital for reducing carbon emissions—they are also key to building a sustainable and resilient energy system for the future. In this article, we explore the pivotal role renewable energy plays in achieving zero-carbon societies and the potential it holds to reshape the global energy landscape.

The Need for Zero Carbon Societies
Zero-carbon societies are those that operate with little to no carbon emissions, primarily focusing on decarbonizing sectors like energy, transportation, agriculture, and industry. The goal is to reach carbon neutrality, where human activities no longer contribute to the accumulation of greenhouse gases (GHGs) in the atmosphere. This is vital in limiting global temperature rise to well below 2°C above pre-industrial levels, as agreed upon in the Paris Agreement.

The energy sector is the largest contributor to global carbon emissions, responsible for approximately 73% of total emissions. Therefore, to achieve carbon neutrality, transitioning away from fossil fuels to renewable energy is not just an option—it is an absolute necessity. This shift can fundamentally alter the way energy is produced, consumed, and distributed, paving the way for sustainable and resilient societies.

Renewable Energy: The Backbone of a Zero-Carbon Future

1. Decarbonizing the Power Sector

The most direct way renewable energy contributes to a zero-carbon society is through the decarbonization of the power sector. Fossil fuels, like coal, natural gas, and oil, are the primary sources of carbon emissions in electricity generation. By replacing these with renewable sources, such as solar and wind power, societies can drastically reduce emissions.

Solar Power:
Solar energy harnesses the sun's rays to generate electricity, producing no emissions during operation. With the cost of solar panels dropping dramatically over the last decade, solar energy has become one of the most cost-effective and accessible sources of renewable power.
Wind Power:
Wind turbines convert the kinetic energy of the wind into electricity. As wind technology has improved, the cost of onshore and offshore wind power has become competitive with traditional fossil fuels, offering a reliable, clean source of energy.
Hydropower:
Hydropower, the largest source of renewable electricity worldwide, uses the flow of water to generate power. While large hydropower plants can have significant environmental and social impacts, small-scale hydro projects and innovations like tidal and wave energy are helping to harness water's power with minimal disruption.
Geothermal Energy:
Geothermal energy taps into the Earth’s internal heat to generate electricity and provide heating. It is a consistent and reliable source of energy, making it ideal for baseload power generation in areas with geothermal resources.

2. Energy Storage and Grid Integration

One of the challenges of renewable energy, particularly solar and wind, is their intermittency. The sun doesn’t always shine, and the wind doesn’t always blow, meaning there are times when renewable energy production falls short of demand. However, significant advancements in energy storage technologies—such as lithium-ion batteries and pumped hydro storage—are making it possible to store excess renewable energy during periods of high production and release it when demand is high or renewable generation is low.

Grid integration is another crucial aspect. Modernizing the electrical grid with smart technologies can improve the efficiency and flexibility of energy distribution. By connecting various renewable energy sources and storage systems, grids can manage fluctuations in supply and demand, ensuring a constant and reliable flow of electricity.

3. Electrification of Other Sectors

Renewable energy is not just about producing electricity—it is also central to the broader decarbonization of other sectors, especially transportation and industry.

Electric Transportation:
The transportation sector, including cars, trucks, buses, trains, and ships, is one of the largest sources of carbon emissions. By shifting from gasoline and diesel to electric vehicles (EVs) powered by renewable electricity, significant reductions in carbon emissions can be achieved. Furthermore, renewable-powered charging infrastructure can ensure that EVs are truly zero-emission.
Green Hydrogen:
Another exciting development is the potential for renewable energy to produce green hydrogen—a fuel produced through the electrolysis of water using renewable electricity. Green hydrogen can be used as a clean energy carrier for sectors that are hard to electrify, such as heavy industry, shipping, and aviation.
Decarbonizing Industry:
Many industries, such as steel and cement manufacturing, rely on high-temperature processes that traditionally depend on fossil fuels. By using renewable electricity or green hydrogen for industrial processes, these sectors can significantly reduce their carbon footprint.

4. Enhancing Energy Access and Equity

Renewable energy can also contribute to more equitable and inclusive societies. By decentralizing energy production through solar panels, wind turbines, and mini-grids, renewable energy can provide electricity to remote and underserved regions that are not connected to the central grid. This decentralized approach not only improves energy access but can also create local jobs and economic opportunities, empowering communities and reducing energy poverty.

The Challenges and Opportunities Ahead
While the potential of renewable energy is immense, there are challenges to its widespread adoption. One of the primary obstacles is the need for substantial investment in infrastructure—particularly in energy storage, grid modernization, and clean technologies. Additionally, the shift from fossil fuels to renewable energy will require strong policy frameworks, financial incentives, and international cooperation.

However, the opportunities presented by renewable energy are equally significant. The rapid advancement of technology, falling costs, and growing global commitment to climate action have made the transition to renewable energy not just feasible, but increasingly attractive. Renewable energy offers not only environmental benefits but also economic growth, job creation, and energy independence.

Conclusion
Renewable energy is indispensable to the realization of zero-carbon societies. From decarbonizing power generation to electrifying transportation and industry, renewables provide a comprehensive and sustainable solution to the climate crisis. While challenges remain, the rapid technological advancements and the urgent need for climate action present a unique opportunity to reshape the energy sector for a cleaner, greener, and more sustainable future. By investing in renewable energy, we can take a monumental step toward building zero-carbon societies that safeguard the planet for future generations.

The Role of Explainable AI in Building Trust and Accountability

Jotty John — Wed, 04 Dec 2024 06:05:53 +0000

Introduction
In recent years, AI has transformed industries by enhancing decision-making processes and automating tasks. However, as AI systems grow more complex, understanding how they make decisions becomes increasingly difficult. This lack of transparency can erode trust and raise ethical concerns, particularly in sensitive areas like healthcare, finance, and law enforcement.

The Need for Explainability
Explainable AI (XAI) refers to methods and tools that help users understand the reasoning behind AI decisions. Unlike traditional "black-box" models, XAI aims to provide clear and interpretable insights. This is crucial in high-stakes applications where accountability and trust are paramount. For example, in healthcare, clinicians need to understand AI recommendations to ensure patient safety and comply with regulations.

Key Benefits of XAI

Building Trust: Transparency in AI processes helps stakeholders feel more confident in adopting AI solutions.
Enhancing Accountability: Organizations can better justify decisions made by AI, mitigating risks of bias or errors.
Compliance with Regulations: As AI governance frameworks evolve, explainability is becoming a legal requirement in regions like the EU (GDPR’s “right to explanation”).

Challenges in Achieving Explainability

Trade-offs with Performance: Simplifying models for explainability can reduce their predictive power.
Complexity of Some AI Models: Techniques like deep learning are inherently difficult to interpret, posing a challenge for transparency.
Balancing Technical and Non-Technical Audiences: Providing explanations that satisfy both technical experts and end-users is tricky.

Use Cases of Explainable AI

Healthcare: XAI aids in interpreting diagnostic models, ensuring doctors understand why specific treatments are recommended.
Finance: In credit scoring and fraud detection, clear explanations help institutions make fair decisions and avoid regulatory penalties.
Legal Systems: XAI supports transparency in AI-assisted sentencing or bail recommendations.

Future Trends
The future of XAI includes advancements in tools and frameworks like LIME and SHAP, which offer model-agnostic explanations. Researchers are also exploring hybrid models that balance interpretability and accuracy. Additionally, AI governance frameworks will likely continue to evolve, emphasizing the importance of XAI in ethical AI deployment.

Conclusion
Explainable AI is a cornerstone of responsible AI development. By fostering trust, enhancing accountability, and ensuring compliance, XAI paves the way for broader adoption of AI technologies in critical sectors. As AI becomes more integrated into daily life, the demand for explainability will only grow, shaping the future of ethical and transparent AI systems.

Revolutionizing Business with APIs and AI: The New Era of Digital Transformation

Jotty John — Thu, 03 Oct 2024 08:30:33 +0000

In the ever-evolving landscape of technology, businesses are increasingly embracing two powerful forces: APIs (Application Programming Interfaces) and AI (Artificial Intelligence). These technologies are not just buzzwords but essential drivers of modern business transformation. Together, they are enabling companies to automate processes, personalize experiences, and create innovative products and services at an unprecedented scale.

This article delves into how APIs and AI are revolutionizing business operations and ushering in a new era of digital transformation, touching on key areas such as automation, data-driven decision-making, customer experience, and innovation.

The API Revolution: Connecting the Digital World
APIs have become the backbone of digital transformation, allowing different systems and applications to communicate with each other effortlessly. They serve as the "connective tissue" between diverse platforms, enabling data exchange and functional integration across applications, devices, and services.

Streamlining Operations and Automating Workflows
APIs allow businesses to automate repetitive tasks and connect siloed systems. For example, integrating CRM software with accounting systems through an API eliminates the need for manual data entry, reducing human error and saving time. This seamless integration of systems is transforming back-office operations, enabling organizations to focus on higher-value activities.
Building an Ecosystem of Innovation
Companies can expand their services and offerings by leveraging third-party APIs. For instance, fintech firms integrate with banking APIs to provide consumers with secure payment gateways, financial data aggregation, or even credit score monitoring. By tapping into external APIs, businesses can offer new capabilities without needing to build these services from scratch, allowing them to scale faster and innovate continuously.
Enabling Omnichannel Experiences
In today’s digital world, customers interact with businesses across various channels—websites, mobile apps, social media, and more. APIs enable businesses to deliver consistent, integrated experiences across all these touchpoints. For example, when customers make a purchase online and return items through a mobile app, APIs ensure that their transaction history, preferences, and loyalty points are updated in real time across all platforms.

The AI Revolution: Intelligence at Scale
While APIs connect systems, AI brings intelligence to those connections, enabling businesses to derive actionable insights, make smarter decisions, and personalize customer experiences.

Enhancing Data-Driven Decision-Making
AI enables businesses to analyze vast amounts of data from APIs and other sources quickly and efficiently. Predictive analytics, powered by AI, helps organizations anticipate market trends, optimize pricing strategies, and forecast demand. With AI-driven insights, businesses can make proactive, data-backed decisions rather than relying on intuition or historical data alone.
For example, in retail, AI can analyze customer purchase patterns, identify emerging trends, and help businesses adjust their product offerings in real time to match changing consumer preferences. In the financial sector, AI can analyze market data and suggest optimal investment strategies, improving profitability.
Personalization at Scale
Today’s consumers expect personalized experiences, and AI enables businesses to deliver exactly that. AI algorithms can analyze customer data—ranging from past purchases to browsing history—and generate tailored recommendations or offers. This level of personalization builds stronger customer loyalty and significantly boosts engagement.
E-commerce giants like Amazon use AI to provide personalized product recommendations, while streaming services like Netflix leverage AI to offer tailored content suggestions based on viewing history. AI's ability to predict customer behavior ensures that businesses can meet consumer expectations efficiently, at any scale.
Intelligent Automation and Productivity
AI, combined with APIs, is fueling intelligent automation across industries. Robotic Process Automation (RPA), for example, uses AI to automate complex workflows, from customer service interactions to supply chain management. Businesses can use AI-driven chatbots to handle routine customer inquiries, freeing up human agents to tackle more complex tasks.
In manufacturing, AI can predict equipment failures by analyzing data collected via APIs from IoT sensors, allowing companies to perform proactive maintenance and reduce downtime. By automating these traditionally manual processes, AI increases productivity, reduces costs, and minimizes errors.

The Symbiotic Relationship Between APIs and AI
While APIs enable connectivity between systems, AI amplifies the capabilities of these systems by interpreting and acting on the data exchanged. Together, APIs and AI provide a powerful combination that enables businesses to innovate, automate, and thrive in today’s competitive environment.

Innovation and New Business Models
APIs and AI are fueling new business models, particularly in sectors like finance, healthcare, and retail. Open banking, for example, allows third-party developers to build financial services on top of existing banking platforms through APIs, while AI-driven fraud detection ensures the security of these transactions.
In healthcare, APIs connect electronic medical records with AI tools that can analyze patient data to suggest personalized treatment plans. In retail, AI-powered recommendation engines integrated via APIs are improving customer experience, leading to higher sales conversions.
Enabling Hyper-Connected Ecosystems
With APIs, businesses can become part of larger digital ecosystems, integrating services from different providers to deliver comprehensive solutions to customers. AI enhances these ecosystems by bringing intelligence into the mix—analyzing user interactions, predicting needs, and enabling real-time adjustments.

For example, a smart home ecosystem may integrate APIs from different vendors for lights, thermostats, and security systems. AI can then analyze usage patterns to automate home settings, offering energy savings and security optimizations that adapt to user preferences.

Challenges and Considerations
While APIs and AI present vast opportunities, they also come with challenges. Security remains a key concern, especially as APIs open gateways to sensitive data. Companies must ensure they implement strong authentication, encryption, and monitoring mechanisms to protect against breaches.

AI, on the other hand, requires quality data for accuracy. Poor data quality or biased data sets can lead to flawed predictions, which could harm business decisions. Transparency and ethical considerations around AI's use are also important, particularly when AI is used to make decisions that directly impact customers or employees.

Conclusion: The Future of Digital Transformation
APIs and AI are not just shaping the future of business—they are defining it. As businesses continue to evolve, the combination of APIs and AI will become even more critical in driving efficiency, innovation, and customer-centric experiences.

In this new era of digital transformation, businesses that embrace APIs and AI will lead the charge, while those that fail to adopt these technologies risk falling behind. By leveraging the power of APIs to connect systems and AI to make sense of data, companies can stay agile, innovate rapidly, and deliver exceptional value to their customers in an increasingly digital world.

Aliens and Me!!

Jotty John — Fri, 27 Sep 2024 13:35:45 +0000

This is a submission for the Web Game Challenge, Build a Game: Alien Edition

What I Built

The player will start on the left side of the game area and can move up and down using up and down arrow keys, while shooting bullets to the right using the space bar. This allows for different strategies when avoiding aliens. When a bullet hits an alien, score will increase by 5 points, a blood splash will appear at the alien's position for a short time before fading out. This gives a visual cue for the hit, enhancing the game's feel.

If an Alien hits a player, he will lose one life. Max 3 lives a player and 100 bullets.

Lets play!!!

Demo

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Alien Shooting Game</title>
    <link rel="stylesheet" href="style.css">
</head>
<body>
    <div id="game-container">
        <div id="lives">Lives: 3</div>
        <div id="score">Score: 0</div>
        <div id="bullet-count">Bullets Remaining: 100</div>        
        <div id="game-over" style="display: none;">Game Over! Press R to Restart</div>
        <div id="player"></div>
        <div id="aliens"></div>
    </div>
    <script src="script.js"></script>
</body>
</html>

style.css

body {
    margin: 0;
    overflow: hidden;
    font-family: 'Arial', sans-serif;
    background: linear-gradient(to bottom, #1c1c1c, #2c2c2c);
    color: white;
    background: url('img/star.jpg') no-repeat center center fixed;
    background-size: cover;
}

#game-container {
    position: relative;
    width: 100vw;
    height: 100vh;
    overflow: hidden;
}
@keyframes fade-out {
    0% {
        opacity: 1;
    }
    100% {
        opacity: 0;
    }
}
#score, #bullet-count, #game-over, #lives{
    position: absolute;
    left: 10px;
    color: white;
    font-size: 20px;
    z-index: 10;
}

#score {
    top: 10px;
}

#lives {
    top: 40px;
}


#bullet-count {
    top: 80px;
}

#game-over {
    top: 50%;
    left: 50%;
    transform: translate(-50%, -50%);
    font-size: 36px;
    text-align: center;
    background: rgba(0, 0, 0, 0.7);
    padding: 20px;
    border-radius: 10px;
}
.blood-splash {
    position: absolute;
    width: 50px; /* Adjust according to your blood splash image size */
    height: 50px; /* Adjust according to your blood splash image size */
    background: url('img/blood-splash.png') no-repeat center center;
    background-size: cover;
    animation: fade-out 0.5s forwards; /* Fade out animation */
}


@keyframes fade-out {
    0% {
        opacity: 1;
    }
    100% {
        opacity: 0;
    }
}
#player {
    position: absolute;
    left: 30px; /* Fixed position on the left */
    bottom: 50%; /* Center vertically (can adjust as needed) */
    width: 30px; /* Adjust according to your player image size */
    height: 50px; /* Adjust according to your player image size */
    background: url('img/player.png') no-repeat center center;
    background-size: cover; /* Make sure the image covers the element */
}
.alien {
    position: absolute;
    width: 25px; /* Adjust according to your image size */
    height: 35px; /* Adjust according to your image size */
    background: url('img/alien.png') no-repeat center center;
    background-size: cover; /* Make sure the image covers the element */
}

.bullet {
    position: absolute;
    width: 10px;
    height: 3px;
     background: url('img/bullet.png') no-repeat center center;
    background-size: cover; /* Make sure the image covers the element */
    border-radius: 2px;
}

script.js

let score = 0;
const player = document.getElementById('player');
const aliensContainer = document.getElementById('aliens');
const scoreDisplay = document.getElementById('score');
const bulletCountDisplay = document.getElementById('bullet-count');
const gameOverDisplay = document.getElementById('game-over'); // Game Over message
const livesDisplay = document.getElementById('lives'); // Lives display
const gameWidth = window.innerWidth;
const gameHeight = window.innerHeight;

let playerPositionY = (gameHeight / 2) - 25; // Center the player vertically
let bullets = [];
let aliens = [];
const MAX_BULLETS = 20; // Maximum number of bullets
let gameInterval; // To store the game interval
let isGameOver = false; // To check if the game is over
let playerLives = 3; // Player lives

// Set the initial position of the player
player.style.bottom = playerPositionY + 'px';
livesDisplay.innerText = "Lives: " + playerLives; // Display initial lives

document.addEventListener('keydown', (event) => {
    if (isGameOver) {
        if (event.key === 'r' || event.key === 'R') {
            restartGame();
        }
        return; // Do not allow movement or shooting if game is over
    }

    // Move the player up and down
    if (event.key === 'ArrowUp' && playerPositionY < gameHeight - 50) {
        playerPositionY += 15; // Move up
    }
    if (event.key === 'ArrowDown' && playerPositionY > 0) {
        playerPositionY -= 15; // Move down
    }
    if (event.key === ' ' && bullets.length < MAX_BULLETS) { // Check bullet limit
        shoot();
    }

    player.style.bottom = playerPositionY + 'px'; // Update player position
});

function shoot() {
    const bullet = document.createElement('div');
    bullet.classList.add('bullet');
    bullet.style.left = '40px'; // Set starting position of the bullet (right of player)
    bullet.style.bottom = (playerPositionY + 15) + 'px'; // Center bullet vertically with respect to the player
    bullets.push(bullet);
    aliensContainer.appendChild(bullet);
    updateBulletCount(); // Update bullet count when a bullet is shot
}

function updateBulletCount() {
    bulletCountDisplay.innerText = "Bullets Remaining: " + (MAX_BULLETS - bullets.length);
    if (bullets.length === MAX_BULLETS) {
        stopGame(); // Stop the game if bullets are used up
    }
}

function createAlien() {
    const alien = document.createElement('div');
    alien.classList.add('alien');
    const xPosition = Math.random() * (gameWidth - 50);
    alien.style.left = xPosition + 'px';
    alien.style.top = '0px';
    aliens.push(alien);
    aliensContainer.appendChild(alien);
}

function moveAliens() {
    for (let i = 0; i < aliens.length; i++) {
        const alien = aliens[i];
        let alienTop = parseInt(alien.style.top);
        if (alienTop < gameHeight) {
            alien.style.top = (alienTop + 2) + 'px';
        } else {
            aliensContainer.removeChild(alien);
            aliens.splice(i, 1);
            i--;
        }
    }
}

function moveBullets() {
    for (let i = 0; i < bullets.length; i++) {
        const bullet = bullets[i];
        let bulletLeft = parseInt(bullet.style.left);
        if (bulletLeft < gameWidth) {
            bullet.style.left = (bulletLeft + 10) + 'px'; // Move bullet to the right
        } else {
            aliensContainer.removeChild(bullet);
            bullets.splice(i, 1);
            i--;
            updateBulletCount(); // Update bullet count when a bullet is removed
        }
    }
}

function checkCollision() {
    for (let i = 0; i < bullets.length; i++) {
        const bullet = bullets[i];
        const bulletRect = bullet.getBoundingClientRect();

        for (let j = 0; j < aliens.length; j++) {
            const alien = aliens[j];
            const alienRect = alien.getBoundingClientRect();

            if (
                bulletRect.x < alienRect.x + alienRect.width &&
                bulletRect.x + bulletRect.width > alienRect.x &&
                bulletRect.y < alienRect.y + alienRect.height &&
                bulletRect.y + bulletRect.height > alienRect.y
            ) {
                // Show blood splash effect at alien position
                showBloodSplashAtAlien(alien);

                score+=5; // Increment score
                scoreDisplay.innerText = "Score: " + score;

                // Remove the bullet and the alien from the DOM
                aliensContainer.removeChild(bullet);
                aliensContainer.removeChild(alien);
                bullets.splice(i, 1); // Remove bullet from array
                aliens.splice(j, 1); // Remove alien from array
                updateBulletCount(); // Update bullet count after hit
                i--; // Adjust index after removal
                break;
            }
        }
    }
    checkPlayerCollision(); // Check collision with player
}

function showBloodSplashAtAlien(alien) {
    const bloodSplash = document.createElement('div');
    bloodSplash.classList.add('blood-splash');
    bloodSplash.style.left = (alien.getBoundingClientRect().x + 'px'); // Position the splash at the alien's X position
    bloodSplash.style.top = (alien.getBoundingClientRect().y + 'px');  // Position the splash at the alien's Y position
    document.body.appendChild(bloodSplash);

    // Remove the blood splash after the animation ends
    setTimeout(() => {
        document.body.removeChild(bloodSplash);
    }, 500); // Adjust timing to match animation duration
}

function checkPlayerCollision() {
    const playerRect = player.getBoundingClientRect(); // Get player dimensions

    for (let alien of aliens) {
        const alienRect = alien.getBoundingClientRect(); // Get alien dimensions
        if (
            playerRect.x < alienRect.x + alienRect.width &&
            playerRect.x + playerRect.width > alienRect.x &&
            playerRect.y < alienRect.y + alienRect.height &&
            playerRect.y + playerRect.height > alienRect.y
        ) {
            playerLives--; // Reduce player life
            livesDisplay.innerText = "Lives: " + playerLives; // Update lives display
            showBloodSplash(); // Show blood splash effect

            // If player has no lives left, stop the game
            if (playerLives <= 0) {
                stopGame(); // Stop the game if the alien touches the player
            }
            break;
        }
    }
}

function showBloodSplash() {
    const bloodSplash = document.createElement('div');
    bloodSplash.classList.add('blood-splash');
    bloodSplash.style.left = (player.getBoundingClientRect().x + 10) + 'px'; // Position it near the player
    bloodSplash.style.top = (player.getBoundingClientRect().y + 10) + 'px'; // Position it near the player
    document.body.appendChild(bloodSplash);

    // Remove the blood splash after animation ends
    setTimeout(() => {
        document.body.removeChild(bloodSplash);
    }, 500); // Adjust timing according to the duration of your animation
}

function stopGame() {
    clearInterval(gameInterval); // Stop the game loop
    isGameOver = true; // Set game over flag
    gameOverDisplay.style.display = "block"; // Show game over message
}

function restartGame() {
    // Reset variables and clear game state
    score = 0;
    playerPositionY = (gameHeight / 2) - 25; // Reset player position
    bullets = [];
    aliens = [];
    playerLives = 3; // Reset player lives
    isGameOver = false;
    scoreDisplay.innerText = "Score: 0";
    bulletCountDisplay.innerText = "Bullets Remaining: 20";
    livesDisplay.innerText = "Lives: " + playerLives; // Reset lives display
    gameOverDisplay.style.display = "none"; // Hide game over message
    aliensContainer.innerHTML = ""; // Clear aliens and bullets

    gameInterval = setInterval(() => {
        if (Math.random() < 0.1) {
            createAlien();
        }
        moveAliens();
        moveBullets();
        checkCollision();
    }, 100);
}

gameInterval = setInterval(() => {
    if (Math.random() < 0.1) {
        createAlien();
    }
    moveAliens();
    moveBullets();
    checkCollision();
}, 100);

img/alien.png

img/blood-splash.png

img/bullet.png

img/player.png

img/star.jpg

Journey

I started with with plain rectangle and circle shapes for aliens and player. Then I used images to make the page more attractive.

Interceptors in Spring Boot

Jotty John — Mon, 16 Sep 2024 07:15:00 +0000

Interceptors in Spring Boot are typically used to intercept and manipulate HTTP requests before they reach the controller or responses before they are sent to the client.

Steps to Implement an Interceptor:
Create an Interceptor Class:

Implement the HandlerInterceptor interface or extend the HandlerInterceptorAdapter class.Override methods like preHandle, postHandle, and afterCompletion based on your needs.

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Component
public class MyInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // Code to execute before the controller method is invoked
        System.out.println("Pre Handle method is called");
        return true; // If false, the request is not further processed
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        // Code to execute after the controller method is invoked, but before the view is rendered
        System.out.println("Post Handle method is called");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // Code to execute after the complete request has finished
        System.out.println("After Completion method is called");
    }
}

Register the Interceptor:

Implement the WebMvcConfigurer interface in a configuration class and override the addInterceptors method to register your interceptor.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    private MyInterceptor myInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(myInterceptor).addPathPatterns("/api/**"); // Specify paths to apply the interceptor
    }
}

Interceptors are specific to Spring MVC and operate at the controller level. Interceptors are typically used for concerns like logging, authentication, and modifying model attributes.