<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>system design on Sadman Kabir Soumik</title>
    <link>https://blog.sksoumik.com/categories/system-design/</link>
    <description>Recent content in system design on Sadman Kabir Soumik</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en</language>
    <copyright>Copyright © 2022, Sadman Kabir Soumik</copyright>
    <lastBuildDate>Wed, 12 Aug 2026 18:00:00 +0000</lastBuildDate><atom:link href="https://blog.sksoumik.com/categories/system-design/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Memory Systems in Agentic AI: Procedural, Semantic, and Episodic Memory</title>
      <link>https://blog.sksoumik.com/artificial-intelligence/memory-systems-agentic-ai/</link>
      <pubDate>Wed, 12 Aug 2026 18:00:00 +0000</pubDate>
      
      <guid>https://blog.sksoumik.com/artificial-intelligence/memory-systems-agentic-ai/</guid>
      <description>
        
          
            Large Language Models are good at understanding text and generating answers.
But there is an important problem.
By default, an LLM does not truly remember everything that happened before.
Imagine you talk to an AI assistant today and tell it:
I prefer short answers and I usually work with Python.
Tomorrow, you start a new conversation.
If the system has no memory, the assistant may know nothing about that previous conversation.
          
          
        
      </description>
    </item>
    
    <item>
      <title>How vLLM Works for Serving Large Language Models</title>
      <link>https://blog.sksoumik.com/artificial-intelligence/how_vllm_works_for_serving_llms/</link>
      <pubDate>Fri, 15 May 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sksoumik.com/artificial-intelligence/how_vllm_works_for_serving_llms/</guid>
      <description>
        
          
            You have downloaded an open source Large Language Model.
Maybe it is Llama, Qwen, Gemma, or another model.
You load it on an NVIDIA GPU and send a prompt:
1What is the capital of Bangladesh? The model answers:
1The capital of Bangladesh is Dhaka. Everything works.
But then 100 users start sending requests at the same time.
Suddenly things become harder.
Some requests wait.
GPU memory fills up.
Your expensive GPU may not be used efficiently.
          
          
        
      </description>
    </item>
    
    <item>
      <title>How to Make LLM Inference Faster</title>
      <link>https://blog.sksoumik.com/artificial-intelligence/how-to-make-llm-inference-faster/</link>
      <pubDate>Sun, 12 Apr 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sksoumik.com/artificial-intelligence/how-to-make-llm-inference-faster/</guid>
      <description>
        
          
            Running a Large Language Model is easy.
Running it fast, at scale, and without wasting expensive GPUs is much harder.
Imagine you deploy an open source LLM on an NVIDIA A100 GPU. Your API works, but users sometimes wait several seconds before they see the first word. When many users arrive at the same time, things get even slower.
Buying more GPUs is one solution.
But it is often not the best first solution.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Building Multi Agent AI Systems: From Orchestration to Production</title>
      <link>https://blog.sksoumik.com/artificial-intelligence/building-multi-agent-ai-systems/</link>
      <pubDate>Thu, 15 Jan 2026 18:00:00 +0000</pubDate>
      
      <guid>https://blog.sksoumik.com/artificial-intelligence/building-multi-agent-ai-systems/</guid>
      <description>
        
          
            Building one AI agent is relatively easy.
You give an LLM some instructions, connect a few tools, and let it perform a task.
For example:
1User 2 ↓ 3Agent 4 ↓ 5LLM 6 ↓ 7Tools 8 ↓ 9Answer But imagine the task becomes much larger.
You want an AI system that can:
Understand a complex request Break the request into smaller tasks Search the web Read internal documents Write code Analyze data Ask another agent for help Remember previous work Check its own results Ask a human before taking risky actions Continue working even when one step fails One agent can try to do everything.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Types of LLM Architectures</title>
      <link>https://blog.sksoumik.com/artificial-intelligence/different-types-of-llms-architectures/</link>
      <pubDate>Tue, 18 Mar 2025 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sksoumik.com/artificial-intelligence/different-types-of-llms-architectures/</guid>
      <description>
        
          
            Let&#39;s first break it down: what exactly are large language models (LLMs), why do we call them &#39;large,&#39; and how are they different from other types of language models?
An LLM is a machine learning model trained on massive amounts of text using transformer-based architectures (or their variations). These models can generate, understand, and process human-like text, making them useful for tasks like translation, summarization, reasoning, coding etc,.
How is an LLM different from other language models?
          
          
        
      </description>
    </item>
    
    <item>
      <title>Building an MLOps Pipeline with Apache Airflow (Part 1)</title>
      <link>https://blog.sksoumik.com/artificial-intelligence/airflow-machine-learning-pipeline/</link>
      <pubDate>Fri, 17 Feb 2023 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sksoumik.com/artificial-intelligence/airflow-machine-learning-pipeline/</guid>
      <description>
        
          
            Author: Sadman Kabir Soumik
Let&#39;s first understand what&#39;s MLOps.
What is MLOps? MLOps (Machine Learning Operations) is a set of practices and tools used to manage the entire lifecycle of machine learning models. MLOps includes everything from data preparation and model training to deployment, monitoring, and ongoing maintenance.
The primary goal of MLOps is to create a streamlined and automated process for deploying and managing machine learning models at scale.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Core Concepts of System Design in Software Engineering</title>
      <link>https://blog.sksoumik.com/software-engineering/system-design-fundamentals-software-engineering/</link>
      <pubDate>Wed, 20 Jul 2022 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sksoumik.com/software-engineering/system-design-fundamentals-software-engineering/</guid>
      <description>
        
          
            What is System Design in Software Engineering? System design in software engineering is defining the structure, components, connections, and information for a system that meets specific needs. It is a vital step in software development as it outlines how the system will work and be structured. A team of developers usually performs this process with input from business analysts and end-users.
Process of Designing a System To create a good software system, we need to follow these steps:
          
          
        
      </description>
    </item>
    
    <item>
      <title>How to Automate and Schedule GCP VM Instance</title>
      <link>https://blog.sksoumik.com/cloud-computing/automate-gcp-compute-engine-vm-instance/</link>
      <pubDate>Sat, 12 Feb 2022 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sksoumik.com/cloud-computing/automate-gcp-compute-engine-vm-instance/</guid>
      <description>
        
          
            Suppose you have a script in the Google Cloud’s VM Instance that needs to run every day/week/month at a particular time ( e.g., a data pipeline for Machine Learning model training, data crawling, etc.). In that case, this article will guide you through automating the task.
Different ways you can automate a script on GCP Your script/program can be in any language, but let’s assume we are trying to automate a Python script for simplicity.
          
          
        
      </description>
    </item>
    
    <item>
      <title>How to design a large scale software system that supports millions of users.</title>
      <link>https://blog.sksoumik.com/artificial-intelligence/designing-large-scale-high-performance-software-systems/</link>
      <pubDate>Fri, 12 Mar 2021 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sksoumik.com/artificial-intelligence/designing-large-scale-high-performance-software-systems/</guid>
      <description>
        
          
            Start With A Simple Architecture To begin building an app, we will start from the beginning. We will create a basic app with some users. The easiest way to do this is to put the whole app on one server. This is a common way to start. The app and any API&#39;s will run on a server like Apache or Tomcat. We will also use a database like Oracle or MySQL.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Comparing REST API and gRPC - Choosing the Right Web API</title>
      <link>https://blog.sksoumik.com/software-engineering/choosing-right-web-api-rest-grpc/</link>
      <pubDate>Fri, 10 Apr 2020 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sksoumik.com/software-engineering/choosing-right-web-api-rest-grpc/</guid>
      <description>
        
          
            REST (Representational State Transfer) and gRPC are two different techniques for creating web APIs (Application Programming Interfaces).
What is REST API? A popular architectural design for developing web APIs is REST. It is built on the HTTP (HyperText Transfer Protocol) and operates on resources defined by URLs using common HTTP methods including GET, POST, PUT, and DELETE. REST APIs are simple to use with a variety of programming languages and tools since they exchange data using the JSON (JavaScript Object Notation) format.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Understanding Dependency Injection - Real-World Examples and Advantages</title>
      <link>https://blog.sksoumik.com/software-engineering/dependency-injection-real-world-examples-advantages/</link>
      <pubDate>Sat, 10 Feb 2018 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sksoumik.com/software-engineering/dependency-injection-real-world-examples-advantages/</guid>
      <description>
        
          
            Dependency injection is a design pattern that is widely used in software development to promote good software design and make code more flexible and easier to test. In this blog post, we will take a closer look at what dependency injection is, how it works, and its advantages.
What is Dependency Injection? Dependency injection is a technique that allows an object to receive its dependencies (other objects it needs to function) from the outside, rather than creating them itself.
          
          
        
      </description>
    </item>
    
  </channel>
</rss>
