DEV Community: Tej Hagargi

CRAG Implementation using TS

Tej Hagargi — Sat, 16 May 2026 08:22:49 +0000

import {
StateGraph,
Annotation,
MessagesAnnotation,
END,
} from "@langchain/langgraph";
import { ChatOpenAI } from "@langchain/openai";
import { HumanMessage, SystemMessage } from "@langchain/core/messages";
import { PineconeStore } from "@langchain/pinecone";
import { embeddings } from "./embeddings";
import { promptTemplate } from "./ragPrompt";

const model = new ChatOpenAI({
modelName: "gpt-4",
temperature: 0,
openAIApiKey: process.env.OPENAI_API_KEY,
});

let vectorStore: PineconeStore | null = null;

async function getVectorStore() {
console.log("[CRAG] getVectorStore called, cached:", !!vectorStore);
if (!vectorStore) {
const { pineconeIndex } = await import("./pinecone");
vectorStore = await PineconeStore.fromExistingIndex(embeddings, {
pineconeIndex,
});
console.log("[CRAG] vectorStore initialized");
}
return vectorStore;
}

const CRAGState = Annotation.Root({
...MessagesAnnotation.spec,
question: Annotation({ reducer: (, b) => b, default: () => "" }),
namespace: Annotation({ reducer: (, b) => b, default: () => "" }),
documents: Annotation({ reducer: (, b) => b, default: () => [] }),
retrievalGrade: Annotation({
reducer: (, b) => b,
default: () => "",
}),
rewrittenQuestion: Annotation({
reducer: (, b) => b,
default: () => "",
}),
answer: Annotation({ reducer: (, b) => b, default: () => "" }),
retryCount: Annotation({ reducer: (_, b) => b, default: () => 0 }),
});

async function retrieve(state: typeof CRAGState.State) {
console.log("[CRAG] retrieve node started");
const store = await getVectorStore();
const query = state.rewrittenQuestion || state.question;
console.log("[CRAG] retrieve query:", query, "namespace:", state.namespace);
const results = await store.similaritySearch(query, 5, {
namespace: state.namespace,
});
const docs = results.map((doc) => doc.pageContent);
console.log("[CRAG] retrieve got", docs.length, "docs");
return { documents: docs };
}

async function gradeDocuments(state: typeof CRAGState.State) {
console.log("[CRAG] LLM grading retrieval...");

const context = state.documents.join("\n\n");

const response = await model.invoke([
new SystemMessage(`
You are a retrieval evaluator.

Determine whether the retrieved documents
are relevant enough to answer the user's question.

Reply ONLY with:

good
bad
`),

new HumanMessage(`
Question:
${state.question}

Retrieved Documents:
${context}
`),
]);

const grade =
typeof response.content === "string"
? response.content.toLowerCase().trim()
: "bad";

console.log("[CRAG] LLM grade:", grade);

return {
retrievalGrade: grade,
};
}

async function rewriteQuery(state: typeof CRAGState.State) {
console.log("[CRAG] rewriteQuery node started");
const response = await model.invoke([
new SystemMessage("Rewrite the user's query to improve vector retrieval."),
new HumanMessage(state.question),
]);
const rewritten =
typeof response.content === "string" ? response.content : state.question;
console.log("[CRAG] rewriteQuery new query:", rewritten);
return { rewrittenQuestion: rewritten, retryCount: state.retryCount + 1 };
}

async function generateAnswer(state: typeof CRAGState.State) {
console.log("[CRAG] generateAnswer node started");
const combinedContext = state.documents.join("\n\n");
const formattedPrompt = await promptTemplate.format({
context: combinedContext,
});
const response = await model.invoke([
new SystemMessage(formattedPrompt),
new HumanMessage(state.question),
]);
const answer = typeof response.content === "string" ? response.content : "";
console.log("[CRAG] generateAnswer produced answer length:", answer.length);
return { answer, messages: [response] };
}

function shouldRetry(state: typeof CRAGState.State) {
console.log(
"[CRAG] shouldRetry grade:",
state.retrievalGrade,
"retryCount:",
state.retryCount,
);
if (state.retryCount >= 2) return "generate";
if (state.retrievalGrade === "bad") return "rewrite_query";
return "generate";
}

console.log("[CRAG] Graph compiled");
export const cragGraph = new StateGraph(CRAGState)
.addNode("retrieve", retrieve)
.addNode("grade_documents", gradeDocuments)
.addNode("rewrite_query", rewriteQuery)
.addNode("generate", generateAnswer)
.addEdge("start", "retrieve")
.addEdge("retrieve", "grade_documents")
.addConditionalEdges("grade_documents", shouldRetry, {
rewrite_query: "rewrite_query",
generate: "generate",
})
.addEdge("rewrite_query", "retrieve")
.addEdge("generate", END)
.compile();

Implementing a Retrieval-Augmented Generation (RAG) Chatbot with LangChain, Firebase, and Pinecone

Tej Hagargi — Thu, 25 Sep 2025 10:50:48 +0000

Recently, I was working on a Retrieval-Augmented Generation (RAG) chatbot where users can upload PDFs or where I can scrape structured website data. The goal was to convert this data into embeddings, store it in a vector database, and then use it to answer user queries.

Step 1: Extract Raw Text

From pdf

import { PdfReader } from 'pdfreader';

let text = '';
const pdfReader = new PdfReader();

await new Promise<void>((resolve, reject) => {
  pdfReader.parseBuffer(buffer, (err: any, item: any) => {
    if (err) reject(err);
    else if (!item) resolve();
    else if (item.text) text += item.text + ' ';
  });
});

From scraped website data:

function extractTextFromScrapedData(data: ScrapedData): string {
  const sections: string[] = [];

  if (data.about) sections.push(`About: ${data.about}`);
  if (data.services) sections.push(`Services: ${data.services.join('\n• ')}`);
  if (data.contact?.phone) sections.push(`Phone: ${data.contact.phone}`);

  return sections.join('\n\n');
}

Step 2: Split Text into Chunks

Long documents need to be split so the LLM can handle them. I used LangChain’s RecursiveCharacterTextSplitter:

import { RecursiveCharacterTextSplitter } from "@langchain/textsplitters";
import { Document } from "@langchain/core/documents";

const doc = new Document({ pageContent: text });
const splitter = new RecursiveCharacterTextSplitter({
  chunkSize: 1000,
  chunkOverlap: 200
});

const allSplits = await splitter.splitDocuments([doc]);
console.log("Chunks created:", allSplits.length);

Step 3: Generate Embeddings + Store

This is the most important part:
When you call vectorStore.addDocuments(), LangChain automatically calls your embedding model (e.g. OpenAI, Cohere) and saves those vectors into your configured database (Pinecone in my case).

import { vectorStore } from "@/app/lib/langchain";

// Store with namespace (client-specific)
await vectorStore.addDocuments(allSplits, { namespace: clientId });
console.log("✅ Documents added to vectorStore");

Step 4: Retrieve Context During Chat

When a user asks a question, we retrieve the top-k similar chunks:

const retrieved = await vectorStore.similaritySearchWithScore(
  userMessage,
  3,
  { namespace: clientId }
);

const relevantMatches = retrieved.filter(([doc, score]) => score > 0.6);
console.log("Relevant matches:", relevantMatches.length);

The other chunking methods are :

Agentic Chunking → LLM-guided, semantic-aware chunking based on meaning and context.
CharacterTextSplitter → Splits by character count (simple, fast).
RecursiveCharacterTextSplitter → Splits by hierarchy (paragraph → sentence → word → char). Most commonly used.
TokenTextSplitter → Splits by tokens, aligns with model tokenization.
MarkdownTextSplitter → Splits Markdown docs by headers/sections.
HTMLTextSplitter → Splits HTML while respecting tags.
CodeTextSplitter → Splits source code by functions, classes, logical blocks.

Refer to this doc for more clarifying
DOC

Happy Coding, Keep Striving.

Docker Essentials for Beginners: What I Learned Building My First Node.js App

Tej Hagargi — Sun, 06 Jul 2025 10:46:40 +0000

Over the past few days, I’ve been diving into Docker and learning how it simplifies development and deployment. I started with a basic Node.js app and ended up understanding key Docker concepts that I’m sharing below — explained in simple terms from a beginner’s point of view.

Why Docker?

Docker simplifies application development, deployment, and scaling by packaging your app along with its dependencies into containers. These containers run the same way in development, testing, or production — ensuring consistency across environments.

First rule: Make sure Docker Desktop is running before executing any Docker commands.

Basic Docker Commands I Learned

docker run -it ubuntu         # Image
docker container ls           # List running containers
docker container ls -a        # List all containers (including stopped)
docker start <container>      # Start a stopped container
docker stop <container>       # Stop a running container
docker exec <container> ls    # Run commands inside the container from host
docker exec -it <container> bash  # Open shell inside the container

Understanding Images vs Containers

Images are the blueprint (environment setup, app code).
Containers are the live, running instances of those images.
Multiple containers can use the same image — they are isolated from each other.

Creating & Sharing Custom Images

Write a Dockerfile to define environment & dependencies.
Build the image (docker build -t codebro-image .).
Push it to Docker Hub.
Your teammates can run it using:

docker pull your-dockerhub/codebro-image
docker run -it your-dockerhub/codebro-image

Docker Networking

Bridge Network (Default)

Isolated network created by Docker.
Containers can talk to each other using names (if on custom bridge).

docker network inspect bridge

Host Network

Shares host machine’s network.

docker run -it --network=host your-image

None Network

No network access (complete isolation).

docker run -it --network=none alpine

Create a Custom Network

docker network create my-custom-network

Port Mapping & Environment Variables

Expose ports from container to host:

docker run -it -p 1025:1025 image-name

Pass environment variables:

docker run -it -p 1025:1025 -e key=value -e key=value image-name

Volume Mounting

Attach host folders to containers for persistent storage:

docker run -it -v /Users/tejhagargi/Desktop:/home/abc ubuntu

Changes in /home/abc inside container reflect on your desktop and vice versa.

Layer Caching

Each line in a Dockerfile becomes a layer. Docker reuses unchanged layers to speed up builds.

FROM node:18           # Layer 1
WORKDIR /app           # Layer 2
COPY package.json .    # Layer 3
RUN npm install        # Layer 4
COPY . .               # Layer 5
CMD ["node", "index.js"]  # Layer 6

Multi-Stage Builds

Build your app in one stage and copy only the necessary files to a clean final image.

FROM node:18 AS builder
WORKDIR /app
COPY . .
RUN npm install && npm run build

FROM node:18-slim
WORKDIR /app
COPY --from=builder /app/dist ./dist
CMD ["node", "dist/index.js"]

Try My Dockerized Node App

docker pull tejhagargi/myfirstnodeapp_docker
docker run -it -p 3000:3000 tejhagargi/myfirstnodeapp_docker

`FROM ubuntu

RUN apt-get update

RUN apt-get install -y curl

RUN curl -sL https://deb.nodesource.com/setup_18.x | bash -

RUN apt-get upgrade -y

RUN apt-get install -y nodejs

COPY package-lock.json package-lock.json
COPY package.json package.json
COPY main.js main.js

RUN npm install

ENTRYPOINT [ "node", "main.js" ]
`

Wrapping Up

Learning Docker has helped me understand how to ship applications reliably. Whether you’re working solo or with a team, containerization is a powerful tool that makes life easier.

If you're also learning Docker, feel free to drop questions or tips in the comments!

🧑‍💻 Happy Dockering!
— Tej Hagargi