Enterprise AI Architect with 16+ years of experience across Software, ML, and Data Engineering. I specialize in taking AI systems from prototype to production.
Stop learning AI tools randomly.
If I were starting my AI engineering journey in 2026, I'd learn these 10 things in this order:
01. Python → Build the foundation
02. LLM APIs → Connect AI models
03. Prompt Engineering → Control model outputs
04. RAG → Give AI access to knowledge
05. Vector Databases → Store and retrieve information
06. AI Agents → Build systems that use tools
07. MCP → Connect AI to external tools and data
08. LangGraph → Build complex AI workflows
09. Evals → Test AI reliability
10. Deployment → Ship real AI products
Here's the truth:
You don't need 50 AI certificates.
You need 3-5 real projects that actually work.
Stop collecting tutorials.
Start building.
Bookmark this roadmap. You'll thank yourself later.
How does ChatGPT answer questions using YOUR data?
It's not magic.
It's RAG (Retrieval-Augmented Generation).
Instead of relying only on what an LLM already knows, RAG allows AI to retrieve relevant information from external knowledge sources before generating an answer.
Here's how the entire RAG pipeline works 👇
1. Data Ingestion
Collect documents, PDFs, websites, databases, and other knowledge sources.
2. Chunking
Break large documents into smaller, meaningful pieces.
3. Embeddings
Convert text chunks into numerical vectors that capture their meaning.
4. Vector Database
Store embeddings in databases like Pinecone, Chroma, or Weaviate.
5. User Query
A user asks a question.
6. Semantic Search
Convert the query into an embedding and find the most relevant chunks.
7. Context Retrieval
Pass the retrieved information to the LLM as additional context.
8. Answer Generation
The LLM uses the retrieved context to generate a relevant answer.
The complete flow:
Documents → Chunking → Embeddings → Vector DB → User Query → Retrieval → LLM → Answer
Why does this matter?
Because RAG helps AI applications:
Access private company knowledge
Answer questions using updated information
Reduce unsupported answers
Build smarter AI assistants
Work with large document collections
Want to build AI applications? Learn RAG.
It's one of the most important concepts in modern AI engineering.
Bookmark this architecture. You'll use it more than you think.
AI engineering is more than just prompting ChatGPT.
If you want to build real AI products, you need to understand how the entire ecosystem works.
Here are 6 things every aspiring AI engineer should learn:
1. RAG: Give AI access to your own data.
2. AI Agents: Build systems that can plan, act, and use tools.
3. AI Tools: Master Python, LangChain, LangGraph, Docker, and more.
4. Prompting vs Engineering: Move from asking questions to building systems.
5. AI Stack: Understand models, frameworks, infrastructure, and data.
6. Building Products: Turn your knowledge into real-world applications.
Don't just learn AI tools.
Learn how to connect them, build with them, and ship something useful.
That's where the real opportunity is.
Bookmark this roadmap. You'll need it.
"Agent memory" isn't one thing. It's seven:
Working: what's in context right now
Semantic: lasting facts
Episodic: past events and how they went
Procedural: learned steps and workflows
Retrieval: looked up on demand (RAG)
Parametric: baked into the model weights
Prospective: reminders and triggers for later
Most real agents combine several of these. Save this for your next agent build.
Which one is hardest to get right in your systems?
Inspired by Neo Kim's original post.
#AIAgents #AgenticAI #LLM #RAG #AIEngineering
Ollama, vLLM, or SGLang? Pick based on your traffic.
Ollama: one user, one machine
• Requests queue up, one at a time per model by default
• Runs quantized GGUF models, or MLX on Apple Silicon
• Best for local dev and prototyping
vLLM: many users, mostly unique prompts
• Continuous batching keeps the GPU busy
• PagedAttention keeps the KV cache tightly packed
• Best for high traffic APIs
SGLang: agents and long chats
• Sends each request to the worker that already holds its prefix
• RadixAttention reuses shared prefixes instead of recomputing them
• Best for tool loops, RAG, and JSON output
Where do you draw the line between needing raw throughput and needing prefix reuse?
#LLM #AIEngineering #AIAgents
I watched Microsoft’s Ignite keynote today in San Francisco. In simple words, this is what they announced.
Microsoft’s AI assistant, Copilot, can now:
Run full Word, Excel, and PowerPoint inside it, with no extra usage cost
Give a team one shared AI space inside Teams
Build a simple app for your company from a plain description
Work with Salesforce, so sales teams can update customer records without switching apps
GitHub’s coding assistant now picks the best AI model for each task. It ranked first on a well known coding test at about half the cost.
The one I keep thinking about is Autopilot. It’s an AI helper that works for your company around the clock, with its own memory, its own email inbox, and its own computer. It can log into old software and keep repetitive work moving overnight. A person still approves the important steps.
That raises fair questions. What happens when a stranger emails it? Who checks its work in the morning? Who is responsible when it gets something wrong?
Microsoft also showed a way to control the cost. Companies can set a hard spending limit on their AI helpers and see what they get back for the money. That part is in early preview.
Chevron showed a design job that normally takes months done in minutes for about $45. That’s impressive. I’d still want to know how long the engineers spent checking the result.
Would you let an AI helper work for you while you sleep? What would it need to prove first?
#MSIgnite
I watched Microsoft’s Ignite keynote today in San Francisco. In simple words, this is what they announced.
Microsoft’s AI assistant, Copilot, can now:
Run full Word, Excel, and PowerPoint inside it, with no extra usage cost
Give a team one shared AI space inside Teams
Build a simple app for your company from a plain description
Work with Salesforce, so sales teams can update customer records without switching apps
GitHub’s coding assistant now picks the best AI model for each task. It ranked first on a well known coding test at about half the cost.
The one I keep thinking about is Autopilot. It’s an AI helper that works for your company around the clock, with its own memory, its own email inbox, and its own computer. It can log into old software and keep repetitive work moving overnight. A person still approves the important steps.
That raises fair questions. What happens when a stranger emails it? Who checks its work in the morning? Who is responsible when it gets something wrong?
Microsoft also showed a way to control the cost. Companies can set a hard spending limit on their AI helpers and see what they get back for the money. That part is in early preview.
Chevron showed a design job that normally takes months done in minutes for about $45. That’s impressive. I’d still want to know how long the engineers spent checking the result.
Would you let an AI helper work for you while you sleep? What would it need to prove first?
#MSIgnite
Most people think building AI apps is just about choosing GPT or Claude.
It's not.
The model is only one part of the AI stack.
Here's what you actually need to understand to build production-ready AI:
LLMs → The brain
AI Agents → Execute tasks
RAG → Retrieve relevant knowledge
Embeddings → Power semantic search
MCP → Connect AI to external tools
Memory → Remember context and preferences
Guardrails → Keep AI safe
Observability → Monitor performance and costs
Frameworks → Bring everything together
The real power comes when all these layers work together.
Knowing how to prompt AI is useful.
Knowing how to build AI systems is a different game.
Don't just learn to use AI.
Learn how to build with it. 🚀
Which layer are you focusing on right now?
#AI #AIAgents #LLM #MCP
The AI agent demo I’d like to see:
Revoke access. Run the same task again.
Can it still retrieve the restricted data?
That’s one of the checks I’d want before trusting an agent with production access.
I’d want to inspect four things:
1. The identity the query actually runs under.
2. The permissions evaluated before execution.
3. What changes when that access is revoked.
4. The audit evidence connecting the request, identity and outcome.
Then I’d check any alternative connection the agent can use.
If it operates through a separate service identity, removing its operator’s access doesn’t tell me whether that service identity still has permission. I need to trace the actual access path.
This is why two findings in @retool’s Governing the Agentic Workplace report caught my attention.
Retool’s Governing the Agentic Workplace report found that 20% of organizations had an unsanctioned tool connected to production data this year, and 13% saw an agent take an unintended action in a production system.
I’d still keep identities distinct. The part I want centralized is the authorization logic.
Teams should be able to build different agents while reusing resource-level access policies. Every new workflow shouldn’t require someone to recreate those rules.
That’s what interests me about Retool’s Data Access Enforcement: table, column and row policies checked before queries reach the database.
The scope matters. Enforcement must be enabled on supported PostgreSQL resources. Connections outside Retool need their own controls.
And permission to update a record doesn’t establish that the update is correct. The team still owns the workflow’s business rules.
The architecture I’d want gives builders a shared foundation: clear identities, enforced permissions, named owners and an audit trail they can follow.
Could your team show exactly where a revoked permission stops the agent’s next query?
Read the report: https://t.co/Hm8b0jfSC8
The same question can need a different answer five hours later.
"Has my order shipped?" means exactly the same thing at 9 a.m. and at 2 p.m. If the carrier collected the package in between, the correct answer changed. A semantic match on the question tells the agent nothing about that.
For an agent handling this, I would separate three decisions:
1. Identify the intent.
2. Retrieve the approved procedure.
3. Check the current order state.
Redis Iris gives each of those its own component.
Intent Router returns a matching intent and target. Your application decides whether and how to dispatch it.
Agent Playbooks supply approved answers and reusable procedures.
Context Gateway connects the agent to tools and Redis data through an MCP endpoint.
The engineering decision I would spend the most time on is what the agent is allowed to reuse. Reusing the order tracking procedure makes sense. Reusing an earlier shipment status needs a freshness policy.
I'd test this directly: ask the same question, change the order state underneath, then ask again and see whether the agent notices.
Who should own the freshness policy in an agent stack, and why?
Redis Iris technical documentation: https://t.co/RZDeFW9pyT
Ollama vs vLLM vs SGLang
They all run open models. But each one shines under a different kind of workload.
𝐎𝐥𝐥𝐚𝐦𝐚: local development
→ Simple setup for running models on your own machine
→ Processes 1 request per model at a time by default, although parallelism can be configured
→ Runs GGUF models via llama.cpp, with an MLX engine on Apple Silicon
→ Supports both OpenAI and Anthropic-compatible APIs, so tools like Claude Code can run against a local model
𝐯𝐋𝐋𝐌: high-throughput serving
→ Continuous batching keeps adding requests as generation runs
→ PagedAttention manages the KV cache in blocks, with prefix caching available
→ Very broad model and hardware support
𝐒𝐆𝐋𝐚𝐧𝐠: shared-prefix-heavy workloads
→ Particularly interesting for agents, RAG and long multi-turn conversations
→ RadixAttention reuses shared prefixes instead of recomputing them
→ Strong support for structured outputs like JSON and regex constraints
A simple way to think about the choice:
→ Prototyping on a laptop or Mac: 𝐎𝐥𝐥𝐚𝐦𝐚
→ Serving lots of users with varied prompts: 𝐯𝐋𝐋𝐌
→ Agents, RAG or long chats that repeatedly reuse context: 𝐒𝐆𝐋𝐚𝐧𝐠
One practical tip if you want prefix caching to actually help:
Keep the stable part of your prompt at the beginning.
System instructions, tool definitions and other repeated context should stay identical where possible. Put the parts that change from request to request later in the prompt.
Small prompt-architecture decisions like this can make a surprisingly big difference once you start serving at scale.
#AI #LLM #SGLANG #VLLM #RAG #FineTuning #DataScience #DeepLearning
Your AI coding agent can explain a function.
Can it explain what depends on it?
That's what I'd want to know before handing it a change request in an enterprise application.
Imagine a simple request:
"Add a 'Needs review' state to the invoice approval workflow."
The implementation might look straightforward. Add the state, update the screen, adjust the logic.
But I'd want the agent to investigate a few things first:
• Which applications consume that approval status?
• Does the ERP integration expect only "Approved" or "Rejected"?
• Which roles can move an invoice out of review?
• What happens to notifications, retries and existing invoices?
A change can look correct inside one application while breaking an assumption somewhere else. And if the tests never covered that assumption, a green test run won't settle the question.
Application context is what I look at when evaluating AI coding tools. I want the agent to inspect the relevant data model, existing logic and dependency relationships before proposing changes. I also want it to distinguish what it found from what it inferred.
𝗪𝗵𝗲𝗿𝗲 𝗢𝘂𝘁𝗦𝘆𝘀𝘁𝗲𝗺𝘀 𝗠𝗖𝗣 𝗳𝗶𝘁𝘀
In OutSystems Developer Cloud, supported coding tools such as Claude Code and Cursor can inspect application screens, data models, logic, roles and dependencies through MCP. App changes are delegated to Mentor, and the MCP server applies the authenticated user's ODC role permissions.
𝗧𝗵𝗲 𝘄𝗼𝗿𝗸𝗳𝗹𝗼𝘄 𝗜'𝗱 𝘄𝗮𝗻𝘁 𝗳𝗼𝗿 𝘁𝗵𝗲 𝗶𝗻𝘃𝗼𝗶𝗰𝗲 𝗲𝘅𝗮𝗺𝗽𝗹𝗲
𝟭. 𝗜𝗻𝘀𝗽𝗲𝗰𝘁 𝘁𝗵𝗲 𝗰𝘂𝗿𝗿𝗲𝗻𝘁 𝗮𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻
Find where approval status is defined, changed and consumed.
𝟮. 𝗘𝘅𝗽𝗹𝗮𝗶𝗻 𝘁𝗵𝗲 𝗽𝗿𝗼𝗽𝗼𝘀𝗲𝗱 𝗶𝗺𝗽𝗮𝗰𝘁
Identify affected applications and integrations. Flag anything the available context cannot establish.
𝟯. 𝗣𝗿𝗼𝗽𝗼𝘀𝗲 𝘁𝗵𝗲 𝗰𝗵𝗮𝗻𝗴𝗲 𝗳𝗼𝗿 𝗿𝗲𝘃𝗶𝗲𝘄
Show the implementation plan, assumptions and tests before making changes.
𝟰. 𝗩𝗮𝗹𝗶𝗱𝗮𝘁𝗲 𝘁𝗵𝗲 𝗯𝗲𝗵𝗮𝘃𝗶𝗼𝗿
Check the new approval path, existing paths and downstream integrations before deployment.
That gives me something concrete to evaluate: whether the agent's proposal accounts for the system around the change.
𝗧𝗵𝗲 𝗯𝗼𝘂𝗻𝗱𝗮𝗿𝘆
An undocumented business exception needs someone to explain it. Access to application context doesn't remove the need for engineering judgment or testing.
When I evaluate an MCP integration, I look at the context it exposes, the work it enables and the permissions governing that work. That's the practical value I'd explore with OutSystems: keeping familiar AI coding tools connected to the applications they're helping us change.
Before your agent edits the application, can it show you what else depends on it?
Try OutSystems MCP with your preferred supported AI coding tool: https://t.co/2cQo7h1mR6
Sponsored by OutSystems.
RAG, AI Agents, MCP, and A2A aren’t competitors.
They’re different layers of the same AI system.
Once you see this mental model, modern AI architecture becomes much clearer 👇
1️⃣ RAG = Better answers
RAG is about retrieval + grounded generation.
Flow:
User question → retrieve relevant data → add context → LLM generates answer with sources.
Use RAG when you need:
• answers from company docs
• reduced hallucinations
• citations and traceability
RAG solves the knowledge problem.
Once the model has enough context to answer, its job is done.
2️⃣ AI Agents = Do the work
Agents move beyond answering.
They plan, act, and iterate.
Typical loop:
Plan → Observe → Act → Reflect → Repeat
Use agents when tasks require:
• multi-step decisions
• tool usage
• executing workflows in real systems
• verifying outcomes
Agents solve the execution problem.
3️⃣ MCP = Standard tool access
MCP (Model Context Protocol) is the plumbing layer.
It standardizes how LLMs connect to tools and resources.
Think:
“One universal interface for AI → tools.”
Use MCP when you need:
• consistent access to APIs and services
• structured connections to SQL, CRM, files, etc.
• fewer custom integrations
MCP solves the tool connectivity problem.
4️⃣ A2A = Agents working together
A2A (Agent-to-Agent) enables multi-agent systems.
It handles:
• agent discovery
• delegation and routing
• permissions and handoffs
• events and status updates
Use A2A when you have:
• multiple specialized agents
• distributed AI systems
• cross-team or partner automation
A2A solves the coordination problem.
The real takeaway:
Modern AI systems often look like this:
RAG → grounding knowledge
Agents → executing tasks
MCP → connecting tools
A2A → coordinating agents
Different problems.
Different layers.
One architecture.
The real AI shift isn’t better prompts.
It’s better systems.
#AI #RAG #AIAgents #LLM #AIArchitecture #GenAI
Your AI agent says “done.”
Your release team opens another checklist.
Who sees it first? What stops a bad rollout?
@LaunchDarkly's Release Autopilot connects canary rollouts to live production signals.