DEV Community: Hitesh

Understand it before you get late

Hitesh — Tue, 24 Feb 2026 12:02:46 +0000

How Claude Multi-Agents work

Hitesh ・ Feb 24

#claude #python #programming #productivity

How Claude Multi-Agents work

Hitesh — Tue, 24 Feb 2026 12:00:09 +0000

Multi-agent systems on Claude work by having multiple AI instances collaborate, each handling specialized tasks, with results passed between them to complete complex workflows.

How It Works

Orchestrator + Subagents pattern is the most common approach. One Claude instance acts as the "orchestrator" that breaks down a complex task and delegates subtasks to specialized "subagent" Claude instances. Each subagent focuses on one thing, returns results, and the orchestrator synthesizes everything.

Communication happens through context — agents don't share memory directly. They pass information via:

Tool call results
Structured outputs (JSON, XML)
Conversation history passed into new API calls

Each agent is stateless — every Claude instance only knows what's in its current context window. So orchestration logic must explicitly carry state forward.

Key Patterns

Sequential pipelines — Agent A's output becomes Agent B's input. Good for: extract → transform → summarize workflows.

Parallel execution — Multiple agents run simultaneously on different subtasks, then results are merged. Good for: analyzing multiple data sources at once.

Hierarchical — Orchestrator → sub-orchestrators → workers. Good for very complex tasks needing multiple layers of decomposition.

Critic/reviewer loop — One agent generates, another reviews/critiques, repeat until quality threshold is met.

In Practice with the API

// Orchestrator call
const plan = await anthropic.messages.create({
  model: "claude-sonnet-4-6",
  system: "You are an orchestrator. Break the task into subtasks and return JSON.",
  messages: [{ role: "user", content: userTask }]
});

// Subagent calls (can be parallelized)
const results = await Promise.all(subtasks.map(task =>
  anthropic.messages.create({
    model: "claude-haiku-4-5-20251001", // cheaper model for subtasks
    system: "You are a specialist agent for...",
    messages: [{ role: "user", content: task }]
  })
));

// Synthesize
const final = await anthropic.messages.create({
  model: "claude-sonnet-4-6",
  messages: [{ role: "user", content: `Synthesize these results: ${JSON.stringify(results)}` }]
});

Kafka interview questions for Data Engineer

Hitesh — Fri, 09 Jan 2026 11:34:30 +0000

Here are Kafka interview questions tailored for AI / Backend / Data Engineer (0–3 yrs) roles, with clear, crisp answers you can revise quickly.
I’ve grouped them by difficulty & topic, exactly how interviews flow.

1️⃣ Kafka Basics (Must-Know)

Q1. What is Kafka?

Answer:
Kafka is a distributed event-streaming platform used for publishing, storing, and consuming streams of records in real time. It is designed for high throughput, fault tolerance, and scalability.

Q2. Kafka vs traditional message queue?

Answer:

Kafka	Message Queue
Pull-based	Push-based
Persistent logs	Messages deleted after consume
Multiple consumers	Usually single consumer
Replay supported	Replay difficult

Q3. What is a topic?

Answer:
A topic is a logical stream of messages where data is written and read.

Q4. What is a partition?

Answer:
A partition is a unit of parallelism in Kafka. Each partition is an ordered, immutable log.

Q5. Why partitions matter?

Answer:
They enable:

Parallel processing
Horizontal scalability
Ordered processing per partition

2️⃣ Producers & Consumers

Q6. What is a Kafka producer?

Answer:
A producer publishes records to Kafka topics.

Q7. How does Kafka decide which partition to write to?

Answer:

Key provided → hash(key) % partitions
No key → round-robin

Q8. What is a Kafka consumer?

Answer:
A consumer reads records from topics.

Q9. What is a consumer group?

Answer:
A consumer group is a set of consumers that share the load of reading partitions.

👉 One partition → one consumer within a group

Q10. What happens if consumers > partitions?

Answer:
Extra consumers stay idle.

3️⃣ Offsets & Delivery Semantics

Q11. What is an offset?

Answer:
An offset is a unique position of a record in a partition.

Q12. How does Kafka track offsets?

Answer:
Offsets are stored in Kafka’s internal topic: __consumer_offsets.

Q13. At-least-once vs At-most-once?

Answer:

At-least-once: no data loss, duplicates possible
At-most-once: no duplicates, data loss possible

Q14. Does Kafka support exactly-once?

Answer:
Yes, using:

Idempotent producers
Transactions

4️⃣ Fault Tolerance & Replication

Q15. What is a broker?

Answer:
A broker is a Kafka server that stores and serves data.

Q16. What is replication factor?

Answer:
Number of copies of a partition across brokers.

Q17. What is leader and follower?

Answer:

Leader: handles reads/writes
Follower: replicates leader data

Q18. What happens if leader fails?

Answer:
A follower is automatically elected as the new leader.

5️⃣ Performance & Reliability

Q19. Why is Kafka fast?

Answer:

Sequential disk writes
Zero-copy transfer
Batching
Page cache usage

Q20. What is ISR?

Answer:
ISR (In-Sync Replicas) are replicas fully caught up with the leader.

Q21. What is `acks` in producer?

Answer:

acks=0 → no guarantee
acks=1 → leader only
acks=all → leader + replicas

6️⃣ Real-World Scenarios (Very Important)

Q22. How do you ensure message ordering?

Answer:
Use the same key so messages go to the same partition.

Q23. How to handle duplicate messages?

Answer:

Idempotent consumers
Deduplication using unique IDs
Exactly-once semantics

Q24. How to reprocess old data?

Answer:
Reset consumer offsets to an earlier value.

Q25. Kafka vs RabbitMQ?

Answer:

Kafka → high throughput, replay, streaming
RabbitMQ → low latency, task queues

7️⃣ Kafka + Data Engineering / AI

Q26. Kafka in ETL pipelines?

Answer:
Kafka acts as a buffer and ingestion layer between producers and downstream ETL systems.

Q27. Kafka with Spark / Flink?

Answer:
Kafka provides real-time data streams; Spark/Flink process them.

Q28. Kafka for ML pipelines?

Answer:
Used for:

Real-time feature ingestion
Streaming inference
Online model updates

8️⃣ Configuration & Monitoring

Q29. How do you monitor Kafka?

Answer:

Lag
Throughput
Broker health
Consumer offsets

Tools:

Prometheus + Grafana
CloudWatch (MSK)

Q30. What is consumer lag?

Answer:
Difference between latest offset and consumer offset.

9️⃣ Advanced (Bonus)

Q31. What is log compaction?

Answer:
Kafka keeps the latest record per key, deleting older ones.

Q32. What is retention policy?

Answer:

Time-based
Size-based

Q33. Schema Registry?

Answer:
Manages schema evolution for messages (Avro/Protobuf).

🔥 5 One-Line Interview Killers

Memorize these:

“Kafka is a distributed commit log.”
“Partitions give scalability; keys give ordering.”
“Offsets enable replayability.”
“Consumer groups provide horizontal scaling.”
“Exactly-once requires idempotent producers and transactions.”

🎯 How to Answer Like a Pro

When stuck, say:

“In production, the choice depends on throughput, ordering, and replay requirements.”

Create MCP into an existing FastAPI backend

Hitesh — Thu, 08 Jan 2026 08:30:46 +0000

You can absolutely integrate MCP into an existing FastAPI backend. There are two primary ways to do this depending on how much control you want over which routes are exposed.

The most common tool for this is the fastapi-mcp library (or the similar fastmcp utility), which acts as a bridge to turn your REST endpoints into "tools" that AI agents can call.

Option 1: Using `fastapi-mcp` (Best for existing apps)

This library is designed to sit on top of your existing FastAPI app. It inspects your routes and automatically generates the MCP schema.

1. Install the package:

pip install fastapi-mcp uvicorn

2. Integration Code:
You only need to add a few lines to your main.py file.

from fastapi import FastAPI
from fastapi_mcp import FastApiMCP

app = FastAPI(title="My Existing Backend")

# Your existing routes
@app.get("/items/{item_id}")
async def read_item(item_id: int):
    return {"item_id": item_id, "name": "Sample Item"}

# Initialize MCP and "mount" it to your app
mcp = FastApiMCP(
    app, 
    name="My Business Tools",
    base_url="http://localhost:8000"
)
mcp.mount() # This creates a /mcp endpoint automatically

Option 2: Using `FastMCP.from_fastapi` (Official SDK style)

If you are using the official mcp Python SDK, it includes a FastMCP class that can wrap a FastAPI app directly.

from fastmcp import FastMCP
from my_app import app # Import your existing FastAPI instance

# Convert the entire FastAPI app to an MCP server
mcp = FastMCP.from_fastapi(app)

if __name__ == "__main__":
    mcp.run()

Key Technical Details

Automatic Tool Mapping: By default, these libraries convert your POST, PUT, and DELETE requests into Tools and your GET requests into Resources.
SSE Transport: FastAPI-based MCP servers typically use Server-Sent Events (SSE). This is ideal because it runs over standard HTTP, meaning you don't need a separate process or complex setup for your AI to talk to your backend.
Filtering Routes: You likely don't want to expose every internal endpoint. You can use the include_operations or exclude_operations arguments to control exactly what the AI sees:

mcp = FastApiMCP(app, include_operations=["get_user_info", "process_order"])

How to use it in your AI Tool (Cursor, Claude, etc.)

Once your server is running (e.g., at http://localhost:8000), you connect your AI agent using the SSE URL:

Endpoint: http://localhost:8000/mcp
Type: SSE

How LLM use MCPs?

Hitesh — Thu, 08 Jan 2026 07:09:13 +0000

To understand how a Large Language Model (LLM) knows what is in a Model Context Protocol (MCP) server, it helps to think of the LLM not as a person who "knows" things, but as a chef who is handed a menu right before they start cooking.

The LLM doesn't actually "know" the MCP exists until the moment you send a message. Here is the step-by-step breakdown of how that discovery happens:

1. The "Handshake" (Discovery)

When you start a session in an MCP-enabled application (like Claude Desktop or Cursor), the MCP Client (the app) talks to the MCP Server (the tool) behind the scenes using a standard request called tools/list.

The server replies with a list of every tool it has.
For each tool, it provides a Name, a Description, and a JSON Schema (the specific arguments it needs).

2. The Context Injection

This is the "aha!" moment. The MCP Client takes that list of tools and injects it directly into the LLM's prompt context (usually in the system instructions).

When the LLM receives your message, it also sees a hidden block of text that looks like this:

"You have access to the following tools:

get_weather: Get current weather. Parameters: location (string).

query_postgres: Run SQL on the DB. Parameters: query (string)."

3. Intent Matching

When you ask, "What's the weather in Tokyo?", the LLM doesn't "run" the tool. Instead, it looks at its instructions and realizes: "I don't know the weather, but I see a tool called get_weather that matches this intent."

Because the LLM is trained to follow "Tool Use" or "Function Calling" patterns, it stops generating regular text and instead outputs a structured snippet:
{ "call": "get_weather", "args": { "location": "Tokyo" } }

4. The Execution Loop

The Client sees this snippet in the LLM's output.
The Client pauses the LLM and sends that specific request to the MCP Server.
The Server runs the actual code and sends the result back to the Client.
The Client feeds that result back to the LLM.
The LLM reads the result and finally gives you the answer: "The weather in Tokyo is 15°C and sunny."

Understanding Polygons and `ST_` Functions in PostGIS

Hitesh — Wed, 28 May 2025 07:49:25 +0000

PostGIS is a powerful spatial extension for PostgreSQL that allows you to store, query, and manipulate geographic objects. If you're working with maps, geometry, or location-based data, PostGIS is an essential tool. In this article, we’ll explore what a polygon is in PostGIS, what the parameters in a polygon definition mean, and the role of ST_ functions in spatial queries.

🧱 What is a Polygon in PostGIS?

A polygon in PostGIS is a two-dimensional geometric object that represents an enclosed area defined by one or more rings:

The outer ring defines the exterior boundary.
Inner rings (optional) define holes within the polygon.

Each ring is made up of at least four coordinate points, and the first and last point must be the same to form a closed loop.

📐 Example: Creating a Polygon

Consider the following SQL query:

SELECT ST_GeomFromText('POLYGON((0 0, 0 5, 5 5, 5 0, 0 0))');

This uses WKT (Well-Known Text) format to define a simple square polygon.

Breaking down the parameters:

POLYGON((0 0, 0 5, 5 5, 5 0, 0 0))

Point	Coordinates	Description
1	`0 0`	Bottom-left corner (starting point)
2	`0 5`	Top-left corner
3	`5 5`	Top-right corner
4	`5 0`	Bottom-right corner
5	`0 0`	Closes the polygon (must match point 1)

This creates a square with sides of 5 units.

🧭 What Does `ST_` Mean in PostGIS?

The ST_ prefix stands for "Spatial Type" and is used for all spatial functions in PostGIS. It follows standards defined by the Open Geospatial Consortium (OGC).

Why use `ST_`?

To clearly distinguish spatial functions from regular SQL functions.
To comply with OGC naming conventions.

🛠️ Common `ST_` Functions

Function	Purpose
`ST_GeomFromText()`	Converts WKT into a PostGIS geometry
`ST_AsText()`	Converts geometry back to WKT
`ST_Area()`	Calculates the area of a polygon
`ST_Length()`	Measures the length of a linestring
`ST_Intersects()`	Checks if two geometries intersect
`ST_Contains()`	Tests whether one geometry completely contains another
`ST_Buffer()`	Expands a geometry outward by a given distance
`ST_Distance()`	Measures the distance between two geometries

🧪 Example Usage

-- Create a polygon from WKT
SELECT ST_GeomFromText('POLYGON((0 0, 0 5, 5 5, 5 0, 0 0))');

-- Compute the area
SELECT ST_Area(ST_GeomFromText('POLYGON((0 0, 0 5, 5 5, 5 0, 0 0))'));

This example returns 25, the area of the 5×5 square.

📦 Summary

A polygon in PostGIS is a closed shape defined by coordinate points.
The parameters in 'POLYGON((x y, x y, ..., x y))' represent the vertices.
The ST_ prefix identifies spatial functions that handle geometry or geography types.

Whether you're building map-based applications or analyzing spatial data, understanding how polygons and ST_ functions work is key to leveraging the full power of PostGIS.

Fast API Request Handling

Hitesh — Mon, 19 May 2025 08:08:05 +0000

In FastAPI, how route handlers (endpoints) behave in terms of parallelism and concurrency depends on whether they are defined using async def or def, and whether the work inside them is I/O-bound or CPU-bound.

Here are the four combinations of route handlers and how they affect parallel or concurrent handling of requests:

✅ 1. `async def` with async I/O-bound work (e.g., `await asyncio.sleep`, database calls)

@router.get("/async-io")
async def async_io_route():
    await asyncio.sleep(2)
    return {"status": "async io"}

Handled concurrently
Non-blocking — multiple such requests can be handled at the same time.
Best performance for I/O tasks like DB queries, network calls, file access.

✅ 2. `async def` with CPU-bound work (e.g., heavy computation, no `await`)

@router.get("/async-cpu")
async def async_cpu_route():
    result = sum(i * i for i in range(10**7))
    return {"result": result}

Not truly concurrent for CPU-bound work.
Blocks the event loop — slows down other async endpoints.
BAD practice — use a thread pool for CPU-bound tasks instead.

✅ 3. `def` with CPU-bound work

@router.get("/sync-cpu")
def sync_cpu_route():
    result = sum(i * i for i in range(10**7))
    return {"result": result}

Parallel execution via thread pool executor (Starlette/FastAPI handles this).
Slower than async I/O but doesn't block the event loop.
Suitable for CPU-bound work when properly limited.

✅ 4. `def` with I/O-bound work (e.g., time.sleep)

@router.get("/sync-io")
def sync_io_route():
    time.sleep(2)
    return {"status": "sync io"}

Blocks thread and wastes resources.
Not concurrent nor parallel in a performant way.
Worst option — avoid using blocking I/O in sync routes.

Summary Table

Route Type	I/O Type	Concurrent?	Notes
`async def`	Async I/O	✅ Yes	Best option for scalable I/O-bound endpoints
`async def`	CPU-bound	❌ No	Blocks the event loop — BAD
`def`	CPU-bound	✅ Parallel	Runs in thread pool — acceptable for CPU tasks
`def`	Blocking I/O	❌ No	Blocks threads — worst case, avoid

✅ Best Practices

Use async def + await for I/O-bound operations.
Offload CPU-heavy operations to a thread/process pool (e.g., run_in_executor()).
Avoid blocking operations like time.sleep() in FastAPI routes.

Here’s a clear and concise table showing different FastAPI route types, the kind of operation they perform, and whether the request handling is parallel or concurrent:

🧩 FastAPI Route Behavior Comparison

Route Type	Operation Type	Example Code Snippet	Behavior	Notes
`async def`	Async I/O-bound	`await asyncio.sleep(1)`	✅ Concurrent	Best for DB queries, API calls, file I/O, etc.
`async def`	CPU-bound	`sum(i * i for i in range(10**7))`	❌ Blocking	Blocks event loop – BAD pattern
`async def`	CPU-bound (offload)	`await loop.run_in_executor(None, cpu_task)`	✅ Parallel	Offloads to thread pool – does not block event loop
`async def`	CPU-bound (multi-core)	`run_in_executor(ProcessPool, cpu_task)`	✅✅ True Parallel	Uses multiple CPU cores – best for heavy computations
`def`	CPU-bound	`sum(i * i for i in range(10**7))`	✅ Parallel	Runs in thread pool – doesn't block event loop
`def`	Blocking I/O	`time.sleep(2)`	❌ Blocking	Wastes threads – avoid blocking I/O in sync functions

✅ Legend

Concurrent: Multiple tasks share the same thread (async I/O).
Parallel: Tasks run in separate threads or processes simultaneously.
Blocking: One task prevents others from proceeding.

How to train LLM faster

Hitesh — Mon, 28 Apr 2025 05:24:49 +0000

RAG is an architecture where an LLM (Large Language Model) is not asked to answer purely from its own parameters but is given external information at runtime to use while answering.

✅ Goal:

Reduce hallucination.
Answer based on updated, private, or niche data without re-training the model.

Breaking Down RAG — Technical View

1. Retriever

Input: A user query (like "What are the side effects of aspirin?")
Goal: Find the most relevant information from an external knowledge source (documents, database, etc.)
How:
- The user query is first passed through an embedding model (like OpenAI text-embedding-ada-002) that turns the text into a high-dimensional vector (like a list of 1536 numbers).
- Stored documents are already embedded beforehand into the same vector space.
- Use vector similarity search (cosine similarity, Euclidean distance, etc.) to find top k nearest documents.

This is exactly like "nearest neighbors search" but in high-dimensional space.

📚 Key Tech Terminologies:

Embedding: Mapping text into numerical vectors capturing semantic meaning.
Vector Database: Special database optimized for fast nearest-neighbor search (e.g., FAISS, Pinecone, ChromaDB).
Cosine Similarity: Mathematical measure of "how similar" two vectors are.
Approximate Nearest Neighbor (ANN): Search algorithm used to make vector search fast in high dimensions.

2. Augmentation

What: After retrieving top relevant documents (say top 5 chunks), we prepare a prompt that includes both:
- The retrieved knowledge.
- The original question.

Example:

Context:
- Aspirin is known to cause stomach ulcers if taken in high doses.
- Patients with asthma may experience worsened symptoms with aspirin.

Question:
What are the side effects of aspirin?

Answer:

This entire constructed text is fed into the LLM.

📚 Key Tech Terminologies:

Prompt Engineering: Crafting the right input text for a model.
Context Window: The maximum number of tokens (words/pieces) the model can take at once. (e.g., GPT-4 Turbo has 128k tokens)

3. Generator

Model's Job: Generate a coherent, fluent, and grounded answer using the provided context.
LLM behavior:
- Reads the question and retrieved context.
- Predicts the next token at each step (one token at a time) until the output is complete.

📚 Key Tech Terminologies:

Autoregressive Language Model: A model that predicts the next word/token given previous words.
Token: A word piece, not always a full word (e.g., "un-", "happi-", "-ness" could be tokens).

What Exactly is a Model (in LLMs)?

✅ Technically:

A model is a huge mathematical function:

$$ f(\text{input}) \to \text{output} $$

✅ More specifically for LLMs:

It's a neural network.
With hundreds of layers of matrix multiplications and nonlinear transformations.
Trained to minimize a loss function (how wrong it was when predicting the next token).

Formula View:

If ( x ) = input tokens, and ( y ) = output tokens,
The model learns a function ( f_{\theta}(x) ) parameterized by θ (weights) such that:
- ( \text{Loss} = \text{CrossEntropy}(f_{\theta}(x), y) ) is minimized.

✅ The model's weights θ are massive matrices — GPT-3 had 175 billion parameters (numbers).

How are LLMs Trained Fastly?

Good question — because LLMs training seems impossible, yet it’s done!

✅ Ingredients to fast LLM training:

Parallelization:
- Data Parallelism: Split the batch across GPUs.
- Model Parallelism: Split parts of the model across GPUs.
- Tensor Parallelism: Split individual matrices inside layers.
- Pipeline Parallelism: Different GPUs work on different sequential layers.
Hardware:
- Specialized hardware: NVIDIA A100, H100 GPUs.
- Use TPUs (Tensor Processing Units) in Google's case.
- Very high memory bandwidth (HBM memory).
Optimization Techniques:
- Mixed Precision Training: Use float16 (half-precision) instead of float32 to make it faster without much loss.
- Gradient Checkpointing: Save memory by recomputing certain activations during backprop.
- AdamW Optimizer: Special gradient descent variant that helps converge faster.
Training Tricks:
- Curriculum Learning: Start easy, go harder.
- Masked Language Modeling (for pretraining): Randomly mask some words to predict.
Distributed Systems:
- Use frameworks like DeepSpeed, Megatron-LM, FSDP (Fully Sharded Data Parallel).
- Train on thousands of GPUs at the same time across multiple datacenters.

✅ Training Dataset Size:

Trillion tokens (Common Crawl, books, code, forums, wikipedia).
LLMs learn token-by-token prediction, very, very slowly but over giant amounts of data.

Summary

Concept	Description
Retriever	Finds relevant data from external source
Augmentation	Adds found documents to the user prompt
Generator	LLM generates an answer based on the prompt
Model	Giant neural network = mathematical function ( f_\theta(x) )
Training Fast	Parallelization, hardware acceleration, optimizer tricks

⚡ Visual View of RAG ⚡

  +-----------------+
  | User's Query (Q) |
  +-----------------+
           |
           v
 +----------------------+
 | Query Encoder (Embed) |
 | (ex: OpenAI Embedding)|
 +----------------------+
           |
           v
 +-------------------------+
 | Similarity Search Engine |
 | (Vector Database: FAISS, |
 | Pinecone, ChromaDB)      |
 +-------------------------+
           |
           v
 +------------------------------+
 | Retrieved Top-K Context Docs |
 +------------------------------+
           |
           v
 +-------------------------------------------------+
 | Construct Final Prompt:                         |
 | [Retrieved Context] + [Original User Question]   |
 +-------------------------------------------------+
           |
           v
 +--------------------------+
 |  Large Language Model (LLM)|
 | (ex: GPT-4, Llama 3)       |
 +--------------------------+
           |
           v
 +---------------------+
 | Generated Final Answer |
 +---------------------+

Waiting for comments!

My Amazon SDE (FTC) Interview Experience 2025

Hitesh — Tue, 01 Apr 2025 11:52:49 +0000

I recently (27-03-2025) had the opportunity to appear for the Amazon SDE interview, which consisted of a Two intense DSA rounds in one day. In these rounds, the interviewer tested me on a mix of problem-solving, logic-building, and optimization awareness. I was asked 4 DSA questions, 2/round, each evaluating different skillsets.

🔹 Question 1: Binary Tree – Sum Tree Validation

Topic: Binary Trees, Recursion

I was given a binary tree and asked to determine if it satisfies a specific sum property (i.e., whether each node’s value equals the sum of its children’s subtree values).

Concepts Tested:

Post-order traversal
Recursive return of tuple (isValid, sum)
Handling base cases for leaf nodes

🧠 Tip: Be confident with writing custom recursive functions and returning multiple values from each call.

🔹 Question 2: Grid BFS – Virus Spread Simulation

Topic: Matrix, Multi-Source BFS

This problem simulated an infection spreading across a 2D grid. Each infected cell (P) spreads to its adjacent non-infected ones (N) per time unit. The task was to compute the minimum time needed to infect all reachable people.

Concepts Tested:

BFS using a queue
Level-wise traversal (multi-source)
Grid bounds and visited updates

🧠 Tip: Practice BFS on 2D grids, especially with multiple starting points.

🔹 Question 3: Range Coverage – Router Signal on Buildings

Topic: Arrays, Prefix Sum, Greedy

Given routers placed on buildings with certain ranges, I had to compute how many buildings are adequately served (i.e., covered by enough routers compared to the number of people in them).

Concepts Tested:

Range marking via prefix sum
Efficient array manipulation
Early stopping conditions

🧠 Tip: Learn how to apply difference arrays to mark and process range updates efficiently.

🔹 Question 4: Graph Reconstruction – Circular Sequence from Pairs

Topic: Graphs, Adjacency List, Traversal

I was given unordered pairs of adjacent symbols forming a circular sequence. The task was to reconstruct a possible valid sequence of those symbols.

Concepts Tested:

Graph building from undirected edges
Identifying a cycle
Visited tracking during DFS or BFS

🧠 Tip: Be ready to reconstruct orderings from unordered pair data, using adjacency lists.

✅ Final Advice

This round tested:

Recursion depth (Tree problems)
BFS reasoning (Simulation & infection spread)
Optimized array processing (Greedy, prefix sum)
Graph traversal and cycle detection

To prepare well:

Master recursion with trees
Practice BFS from multiple sources
Learn range-based greedy techniques
Get comfortable with graph fundamentals using adjacency lists

I still don't know if there are even implementing these algorithms Amazon. Waiting for the result :/

Introducing my project GitFilter! Looking for contributions!

Hitesh — Thu, 27 Feb 2025 14:21:51 +0000

Release 0.0.1

Hitesh for GitFilter ・ Feb 27 '25

#opensource #nextjs #javascript #github

Looking for Devs!

Hitesh — Thu, 27 Feb 2025 14:20:49 +0000

Release 0.0.1

Hitesh for GitFilter ・ Feb 27 '25

#opensource #nextjs #javascript #github

Release 0.0.1

Hitesh — Thu, 27 Feb 2025 14:11:43 +0000

Hola Devs! This is our first post on Dev.to and We are excited to introduce the first release of GitFilter (0.0.1)—a platform designed to help developers discover impactful repositories, showcase their contributions, and enable organizations to find open-source talent. Our focus is on building a community-driven, open-source solution that makes navigating the open-source ecosystem easier and more effective.

This release lays the foundation for GitFilter’s core functionality, including GitHub OAuth authentication, repository search, user profile display, and skill-based filtering. Let’s dive into the details of our Release 0.0.1 and how you can contribute to shaping its future!

Note: If you are a developer, fill this form to contribute!

Technologies We Are Using

For the MVP, we have carefully chosen technologies that ensure scalability, security, and a great developer experience:

Frontend: Next.js (App Router) – Provides server-side rendering, fast performance, and better SEO.
UI Styling: Tailwind CSS – A utility-first CSS framework for responsive and modern UI.
Authentication & Database: Supabase – An open-source Firebase alternative for authentication, database management, and real-time updates.
Backend: Next.js API routes – Eliminates the need for a separate backend, making API handling smoother.
Hosting: Vercel – Ensures fast deployments and seamless scaling.

This tech stack allows us to move quickly while ensuring maintainability and future extensibility.

Why Contribute to GitFilter?

GitFilter is more than just a platform—it’s a community-driven initiative to enhance the open-source experience. Here’s why you should contribute:

🔹 Build the Future of Open Source Discovery – Help create a tool that empowers developers and organizations to collaborate effectively.

🔹 Gain Visibility in the Community – Your contributions will be acknowledged, and you’ll be part of an open-source project that aims to scale globally.

🔹 Learn & Grow – Work with Next.js, Supabase, and modern web technologies while collaborating with developers worldwide.

🔹 Make Open Source More Accessible – Help contributors find projects that match their interests and skills effortlessly.

If you’re a developer passionate about open-source, your contributions will directly shape GitFilter's evolution.

How GitFilter Benefits Developers

✅ Showcase Your Contributions – Your GitHub activity and skillset are displayed in a structured way, making it easier to present your work.

✅ Discover Projects That Matter – Instead of endlessly searching, get curated recommendations for repositories to contribute to.

✅ Connect with Organizations – Organizations looking for skilled contributors can find you based on your real-world open-source contributions.

✅ Filter Repositories Based on Interests – Whether you prefer web dev, AI, or systems programming, GitFilter helps you find the right projects.

Join Us – Contribute to GitFilter!

We believe in the power of community-driven development and want you to be part of GitFilter’s journey.

If you’re interested in contributing, fill out this form to get involved

We hope to open-source our Release 0.0.1 soon if everything goes well. Stay tuned, and let’s build the future of open-source collaboration together! 🚀

Find us below

Open for Sponsorships and Collabs, Follow Founder

Bring your ideas and thoughts to enhance this platform in comment section below!

(Participants will be getting a big surprise!)

DEV Community: Hitesh

Understand it before you get late

How Claude Multi-Agents work

Hitesh ・ Feb 24

How Claude Multi-Agents work

How It Works

Key Patterns

In Practice with the API

Kafka interview questions for Data Engineer

1️⃣ Kafka Basics (Must-Know)

Q1. What is Kafka?

Q2. Kafka vs traditional message queue?

Q3. What is a topic?

Q4. What is a partition?

Q5. Why partitions matter?

2️⃣ Producers & Consumers

Q6. What is a Kafka producer?

Q7. How does Kafka decide which partition to write to?

Q8. What is a Kafka consumer?

Q9. What is a consumer group?

Q10. What happens if consumers > partitions?

3️⃣ Offsets & Delivery Semantics

Q11. What is an offset?

Q12. How does Kafka track offsets?

Q13. At-least-once vs At-most-once?

Q14. Does Kafka support exactly-once?

4️⃣ Fault Tolerance & Replication

Q15. What is a broker?

Q16. What is replication factor?

Q17. What is leader and follower?

Q18. What happens if leader fails?

5️⃣ Performance & Reliability

Q19. Why is Kafka fast?

Q20. What is ISR?

Q21. What is acks in producer?

6️⃣ Real-World Scenarios (Very Important)

Q22. How do you ensure message ordering?

Q23. How to handle duplicate messages?

Q24. How to reprocess old data?

Q25. Kafka vs RabbitMQ?

7️⃣ Kafka + Data Engineering / AI

Q26. Kafka in ETL pipelines?

Q27. Kafka with Spark / Flink?

Q28. Kafka for ML pipelines?

8️⃣ Configuration & Monitoring

Q29. How do you monitor Kafka?

Q30. What is consumer lag?

9️⃣ Advanced (Bonus)

Q31. What is log compaction?

Q32. What is retention policy?

Q33. Schema Registry?

🔥 5 One-Line Interview Killers

🎯 How to Answer Like a Pro

Create MCP into an existing FastAPI backend

Option 1: Using fastapi-mcp (Best for existing apps)

Option 2: Using FastMCP.from_fastapi (Official SDK style)

Key Technical Details

How to use it in your AI Tool (Cursor, Claude, etc.)

How LLM use MCPs?

1. The "Handshake" (Discovery)

2. The Context Injection

3. Intent Matching

4. The Execution Loop

Understanding Polygons and `ST_` Functions in PostGIS

🧱 What is a Polygon in PostGIS?

📐 Example: Creating a Polygon

Breaking down the parameters:

🧭 What Does ST_ Mean in PostGIS?

Why use ST_?

🛠️ Common ST_ Functions

🧪 Example Usage

📦 Summary

Fast API Request Handling

✅ 1. async def with async I/O-bound work (e.g., await asyncio.sleep, database calls)

✅ 2. async def with CPU-bound work (e.g., heavy computation, no await)

✅ 3. def with CPU-bound work

✅ 4. def with I/O-bound work (e.g., time.sleep)

Summary Table

🧩 FastAPI Route Behavior Comparison

✅ Legend

Q21. What is `acks` in producer?

Option 1: Using `fastapi-mcp` (Best for existing apps)

Option 2: Using `FastMCP.from_fastapi` (Official SDK style)

🧭 What Does `ST_` Mean in PostGIS?

Why use `ST_`?

🛠️ Common `ST_` Functions

✅ 1. `async def` with async I/O-bound work (e.g., `await asyncio.sleep`, database calls)

✅ 2. `async def` with CPU-bound work (e.g., heavy computation, no `await`)

✅ 3. `def` with CPU-bound work

✅ 4. `def` with I/O-bound work (e.g., time.sleep)