<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>artificial intelligence on Sadman Kabir Soumik</title>
    <link>https://blog.sksoumik.com/categories/artificial-intelligence/</link>
    <description>Recent content in artificial intelligence 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/artificial-intelligence/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>How LLM Post Training Works: SFT, Preference Training, Reinforcement Learning, and Distillation</title>
      <link>https://blog.sksoumik.com/artificial-intelligence/how-llm-post-training-works/</link>
      <pubDate>Sun, 14 Dec 2025 18:00:00 +0000</pubDate>
      
      <guid>https://blog.sksoumik.com/artificial-intelligence/how-llm-post-training-works/</guid>
      <description>
        
          
            Training a large language model usually happens in more than one stage.
The first stage is pretraining.
This is where the model learns language, facts, patterns, coding concepts, reasoning patterns, and many other things from a very large amount of data.
But a pretrained model is not automatically a good assistant.
It might know a lot, but it may still struggle to follow instructions, answer in the right format, understand human preferences, or behave the way we want.
          
          
        
      </description>
    </item>
    
  </channel>
</rss>
