DEV Community: Maksym Mosiura

AI and Human Will

Maksym Mosiura — Tue, 10 Mar 2026 09:42:17 +0000

Wherever you look today - a news feed, a podcast, a conference keynote — someone is always telling that AI will transform everything. It can be your job, your community, your world or even your thoughts. The signal is genuine. The transformation is real. And the most important question goes largely unasked:

how do we choose to think about it?

That's what I will try to answer in this article.

The idea is simple - how we think about it will determine how we live through it.

This Has Happened Before

History is reassuring, if you know where to look. The rise of AI is not the first time a technological leap made whole categories of human work feel suddenly obsolete.

Consider the assembly line. Before its invention a lot of industries of producing complex goods (e.g. automobiles, metal structures, packaged food) required skilled workers at every stage. These stages were moving materials, inspecting quality, assembling components by hand, etc.. The process was slow, expensive, and deeply human. Then Ford and others reorganized production around continuous flow - that's where nearly everything changed. Their assembly lines changed the whole industry:

manufacturing became faster;
products became more affordable to the masses;
and produces becomes cheaper. That's when a wide swath of workers found their specialized knowledge replaced by repetitive, interchangeable tasks.

The pattern that followed is pretty instructive: industries were disrupted, but new industries emerged.

Many of skills became obsolete, and new skills took their place. Many moved to specialized places for some time to support uniqueness. Still a lot really disappear. The people who adapted, people who understood the new tools, who found the human layer that automation could not replicate were the ones who shaped what came next.

That same pattern is unfolding again today. And like every time before, it is not reversible. The future has already begun.

The Race No One Wins by Standing Still

A programmer who was excellent last year may find that AI can now produce comparable code faster and cheaper. This is not a reflection of their talent. It is a reflection of the tool's capability. The uncomfortable truth is that being good at your craft is no longer sufficient protection. A machine can approximate that craft on demand. Maybe it is not ideal, maybe it is buggy, but still allowable in general.

So how do you think about a future that looks, at first glance, so threatening?

The answer is straightforward, even if the path is not:

improve yourself.

Not in the generic, or motivational sense. Rather in a very specific sense. You have to ask a question: What AI cannot do? What no tool can do?

The answer is:

carry responsibility.

The One Thing Machines Don't Have

For an AI system, a failed outcome is simply a failed output. It can be logged, retried, discarded, revisited etc.. There is no consequence felt, no lesson internalized, no stake in what happens next. Even if context is correct, even if the previous lessons learned and cached - the problem is the same - no responsibility.

In the real world, consequences are not always recoverable. Decisions ripple outward — into people's lives, into ecosystems, into economies. When something goes wrong, someone must answer for it. Someone has to be obliged to explain the reasons of that and solutions to correct consequences.

Think about how AI-only decision-making might unfold inside an organization:

Company → request to AI → AI acts → wrong decision made → no accountability → reputational or financial damage

Now compare that to a process where a human is in the loop:

Company → decision maker → validated reasoning → AI executes → decision maker accountable → outcomes reviewed and refined

The difference is not efficiency. The difference is ownership. The second process is slower in places — and that slowness is a feature, not a bug. It is where judgment lives.

Full automation may be appropriate in narrow or well-defined scenarios. Still as a general model for consequential decisions, it fails the moment complexity enters the picture: it can be hidden motivations, competing priorities, long-term goals, political context, ethical nuance or many other things that can't be explained to AI or put to the context. These are not edge cases. They are the substance of real decisions.

AI is an extraordinary lens: it can surface options you hadn't considered, test your reasoning against scenarios you hadn't imagined, and identify blind spots you didn't know you had. But the lens does not look at itself. A person can. You do!

Again, this is about the ownership and responsibility.

The Skills That Actually Matter Now

This reframing opens something important. If AI handles the execution layer — the generation, the computation, the pattern-matching — then the human layer moves upward. The skills that grow in value are not the ones that compete with AI. They are the ones that use it well.

Systems thinking. Logical reasoning under uncertainty. The ability to hold a complex picture in mind and ask the right questions of it. Critical validation — not accepting an output because it sounds plausible, but interrogating it:

Is this accurate?
Is this context-appropriate?
Is this a hallucination, a misinterpretation, a confident-sounding error?
Is this ...?

The shift is from using AI as a tool that solves your problems, to using AI as a partner that makes you sharper and smarter at solving them yourself. The former makes you dependent. The latter makes you stronger.

What We Can Teach the Next Generation

This question has a particular urgency when it comes to young people. Today's teenagers and children have grown up with instant answers. Ask ChatGPT. Craft an essay. Get a solution. The friction that builds capacity - the cognitive work, it just gets bypassed.

The brain, like any muscle, develops through resistance. When young people outsource their thinking to the AI, they are not saving time. They are skipping the training that builds judgment, skepticism, and intellectual confidence.

How old system would solve this:

more homework;
more lessons;
more class hours, etc. This approach will not fix this. What can fix it is Will — the deliberate choice to engage with hard problems rather than hand them off. To use AI as a scaffold for exploration rather than a substitute for thought. Instead of blindly trust any answer from the AI, the critical thinking should be triggered. Why? To ask: is this answer actually right? How do I know? What would change it? Is this a fact or someone's joke or misinterpretation?

Critical thinking is not a subject. It is a habit. And habits are built through practice, not policy.

Will Is the Differentiator

The people who thrive in the era of AI will not necessarily be the most technically skilled. They will be the ones who choose to remain active, rather than passive. They will be the ones who use these tools to extend their thinking rather than replace it.

learning instead of consuming

Will is the genuine, self-directed commitment to growth. Will is what separates a consumer from a creator and a user from a builder. Someone carried by the current will be behind from someone who learns to navigate it. It was always a case, this is not something new.

The future does not belong to those who fear AI, nor to those who blindly trust it. It belongs to those who understand what it is: a powerful, irresponsible, context-blind instrument.
The ones who bring their own compass to it, who refuse to outsource their judgment along with their tasks, are the ones who will define what comes next.

Revolutionizing Wine Industry Technology: Why Micro Frontends Require Specialized Expertise

Maksym Mosiura — Sat, 11 Oct 2025 23:15:36 +0000

The Digital Transformation Imperative in Wine
The wine industry stands at a critical crossroads in 2025. As demographic shifts accelerate and consumer preferences evolve, wineries face unprecedented pressure to modernize their digital infrastructure. The consolidation of platforms like Commerce7's acquisition of WineDirect, the emergence of sophisticated DTC systems, and the explosive growth of the subscription economy signal a fundamental transformation in how wineries must engage with customers.

Today's wine businesses require complex, multi-faceted digital ecosystems that seamlessly integrate e-commerce platforms, wine club management, tasting room experiences, inventory systems, customer relationship management, compliance tracking, and virtual engagement tools. The traditional monolithic approach to building these platforms has become a bottleneck, creating development friction, deployment delays, and scalability nightmares.
This is where micro frontends represent not just an evolution, but a revolution for the wine industry.

What Makes Micro Frontends with Module Federation Truly Innovative

Micro frontends break the monolithic frontend architecture into smaller, independently deployable applications. When combined with Webpack 5's Module Federation, NX monorepos, and Zephyr Cloud deployment, this architecture creates a powerful paradigm that seems tailor-made for the wine industry's unique challenges.

Module Federation introduces a groundbreaking capability - applications can share code and consume components from other applications at runtime without rebuilding or redeploying the entire system. For wineries, this means the e-commerce team can deploy new features to the shopping cart experience while the wine club team simultaneously updates membership management, all without coordination nightmares or system-wide deployments.

NX monorepos provide the orchestration layer, offering intelligent caching, code generation, and build optimization that can reduce CI/CD pipeline times from minutes to seconds. Meanwhile, Zephyr Cloud revolutionizes deployment by taking snapshots of applications and deploying them to the edge in sub-seconds, making "testing in production" a viable reality rather than a dangerous gambit.

The Brand-New Challenges That Demand Expertise

Here's the critical truth that many organizations overlook: implementing micro frontends with Module Federation is deceptively complex. The challenges facing development teams in 2025 are not merely technical—they represent entirely new problem spaces that require specialized knowledge and battle-tested expertise.

1. Dependency Version Management: The Distributed Nightmare
In traditional monolithic applications, managing dependencies is straightforward. In a micro frontend architecture with Module Federation, it becomes an intricate chess game. Consider this scenario: your host application uses React 18.2.0, but a remote wine club module depends on React 17.0.2. This version mismatch doesn't just cause warnings—it breaks fundamental features like useState, useEffect, and shared context, potentially crashing the entire user experience.

Module Federation's shared API provides a solution through singleton enforcement. Though you can have them made with a factory. Anyway, configuring it correctly requires deep understanding of:

Semantic versioning and compatibility matrices
The webpack Module Federation configuration file (which exists outside the build process)
How to handle breaking changes across distributed teams
The trade-offs between strict versioning and flexible integration

The complexity multiplies exponentially as you add more micro frontends. A wine business platform might have separate modules for inventory, e-commerce, club management, tasting room bookings, compliance tracking, and marketing automation. Each module potentially introduces its own dependency tree, and ensuring they all work harmoniously requires sophisticated dependency conflict resolution strategies that most developers have never encountered.

2. Runtime Integration and Performance Optimization
Module Federation enables runtime code sharing, but this introduces performance challenges that are fundamentally different from traditional bundling approaches. Key issues include:

Increased Payload Size: Each micro frontend must include its own runtime and initialization code. Without careful optimization, users could download duplicate dependencies, bloating the application and degrading performance—a critical concern for customer-facing wine e-commerce experiences where every millisecond of load time impacts conversion rates.

Lazy Loading Orchestration: Experts must implement sophisticated lazy loading strategies, determining which modules load on initial page render versus on-demand. For a winery's online store, this might mean instantly loading the product catalog while deferring the wine club signup module until needed.

Cache Management: With multiple independently deployed modules, cache invalidation becomes a distributed systems problem. When the tasting room booking module updates, how do you ensure users get the latest version without forcing a full page reload or breaking the user experience?

3. The NX Monorepo Mastery Requirement
While NX dramatically simplifies micro frontend development, mastering it requires significant expertise. Development teams must understand:

Code Generators and Schematics: NX provides powerful code generation tools, but using them effectively requires understanding the underlying patterns and architectural decisions.

Dependency Graph Management: NX visualizes and manages dependencies between apps and libraries within the monorepo. For a wine platform with dozens of shared libraries (authentication, design system, payment processing, compliance utilities), understanding and maintaining this graph is crucial.

Incremental Builds and Computation Caching: NX's intelligent caching can speed up builds by 10x or more, but only if configured correctly. This requires deep knowledge of task orchestration, affected project detection, and distributed caching strategies.

Module Federation Configuration: NX streamlines Module Federation setup, but developers still need to understand the underlying webpack configuration, remote entry points, and how to expose and consume federated modules correctly.

4. Zephyr Cloud Deployment: The New Frontier
Zephyr Cloud represents a paradigm shift in micro frontend deployment, but leveraging it effectively requires understanding concepts that didn't exist in traditional deployment workflows:

Sub-Second Deployments: Zephyr can deploy to the edge in milliseconds, enabling true preview environments and rapid iteration. However, orchestrating multiple micro frontends with different deployment cadences requires sophisticated release management.

Version Management Across Distributed Frontends: When you have five micro frontends deployed independently, managing version compatibility and rolling back problematic releases becomes exponentially more complex than traditional deployments.

Edge Distribution: Zephyr deploys to the edge for optimal performance, but this introduces new considerations around cache propagation, regional consistency, and debugging production issues that manifest only in specific geographic regions.

5. Testing in a Distributed Architecture
Testing micro frontends represents an entirely new challenge domain:

Integration Testing Across Boundaries: Each micro frontend may work perfectly in isolation, but how do you test their integration? You need comprehensive integration test suites that can load and test multiple federated modules together.

Version Compatibility Testing: With independently versioned modules, you must test all possible version combinations—a combinatorial explosion that requires intelligent test strategies.

End-to-End Testing Complexity: E2E tests must now account for modules loading asynchronously, potential network failures during module loading, and the complexity of multiple independently deployed frontends.

6. Monitoring and Debugging: The Distributed Systems Challenge
When something goes wrong in a monolithic application, debugging is relatively straightforward. In a micro frontend architecture:

Distributed Tracing: Errors can originate from any of dozens of federated modules. Implementing comprehensive distributed tracing to track user actions across module boundaries requires specialized tools and expertise.

Performance Monitoring: You need to monitor not just overall application performance, but the load times and performance of individual federated modules, identifying bottlenecks in the distributed architecture.

Error Attribution: When a production error occurs, determining which micro frontend, which version, and which team is responsible requires sophisticated logging and error tracking infrastructure.

7. Security and Authentication in a Distributed Context

Sharing authentication state and managing security across independently deployed micro frontends introduces challenges that don't exist in monolithic apps:

Shared Authentication State: How do you ensure all micro frontends share the same authentication token and user session without creating security vulnerabilities?

Authorization Consistency: Each module may have different authorization requirements (e.g., regular customers vs. wine club members vs. tasting room staff). Maintaining consistent authorization logic across distributed modules is non-trivial.

Secure Module Loading: Module Federation loads code from multiple sources at runtime. Ensuring this doesn't create security vulnerabilities (like code injection or man-in-the-middle attacks) requires careful configuration and security expertise.

Why the Wine Industry Needs This Innovation Now
Despite these challenges, micro frontends with Module Federation, NX, and Zephyr represent exactly what the wine industry needs in 2025:

Team Autonomy: Different teams can work on e-commerce, wine clubs, tasting rooms, and inventory independently, matching the organizational structure of modern wineries.

Rapid Innovation: Deploy new features to specific customer touchpoints without risking the entire platform—critical in an industry racing to meet evolving consumer expectations.
Scalability: As wineries grow, add new micro frontends for new business units or acquisition integration without architectural rewrites.

Performance: Edge deployment with Zephyr ensures fast load times for customers worldwide, directly impacting conversion rates and customer satisfaction.

Technology Flexibility: Different teams can use different frameworks or versions as needed, future-proofing the architecture as technology evolves.

The Bottom Line: Expert Implementation is Non-Negotiable
The convergence of Module Federation, NX monorepos, and Zephyr Cloud deployment represents the cutting edge of frontend architecture in 2025. For the wine industry, this technology stack offers transformative potential—but only if implemented correctly.

The challenges outlined above aren't hypothetical. They're real problems that development teams encounter daily when building micro frontend architectures. These are fundamentally new problems that require specialized expertise. A team experienced in traditional monolithic frontends, or even microservices on the backend, will struggle without guidance from experts who have battle-tested knowledge of:

Advanced webpack Module Federation configuration
NX monorepo architecture and optimization
Zephyr Cloud deployment strategies
Distributed systems monitoring and debugging
Micro frontend testing strategies
Version management across independent modules
Performance optimization in distributed architectures

For wineries investing in digital transformation, partnering with experts who understand these challenges isn't optional—it's essential. The technology is innovative and powerful, but the path is littered with pitfalls that can waste months of development time and millions in investment.

The future of wine industry technology is modular, distributed, and sophisticated. Success requires not just adopting new tools, but embracing new paradigms—with the guidance of those who have already navigated the complexity.

MCP? What is that?

Maksym Mosiura — Tue, 07 Oct 2025 07:10:58 +0000

MCP stands for Model Context Protocol. It’s like a special language or system that helps AI programs talk to other software and data easily. Think of it like a super helpful bridge or bridges.

Today, AI models like ChatGPT or Claude need to get information from lots of places. Without MCP, this is hard. MCP makes it easy for AI to access data, connect to apps, and do tasks. This saves time and makes AI smarter.

People use MCP because it solves their unique problems. Before, AI models couldn’t easily work with other tools or databases. MCP changes that. It lets AI not just read information but also take actions—like booking a ride or checking a calendar.

MCP is mostly used by developers building apps today. It’s popular in coding tools and automation software. It helps AI work faster and do more things on its own.

Also, MCP is easy to make and share with others, including AI tools.

We, as humans, can communicate with words. As developers we can make interfaces to our applications. But AI can't make the interfaces or consume them correctly. That's the place where MCP needed - to help with this kind of communication. This is an adapter that can be used by AI to use one application or service.

How MCP Changes the AI Market
Today MCP is shaking up the AI world. It’s like giving every AI superpowers to connect and work with real-world data and tools.

Because MCP makes connections standard and simple, many new AI apps and tools are popping up. More people can create AI-powered solutions without building everything from scratch.

Companies see MCP as a way to win in AI. It lowers costs and speeds up projects. Also, MCP is inspiring new business ideas where developers can make money by sharing AI tools that talk through MCP.

How Much Is MCP Used? Here Are Some Numbers
A lot of MCP servers exist today. Some lists show from 5,000 to 16,000 different MCP servers out there. But here’s the catch: most of these servers aren’t used much or used at all. Studies show that about 90% or more are mostly untouched 🤯.

Usage is really focused on just a few popular servers. The top 10 servers get almost half of all the attention and use. Most MCP servers are still in early stages or experimental.

Even though many exist, that small few do most of the real work. This means the MCP ecosystem is still young and growing. The excitement and downloads are increasing quickly, with month-over-month growth sometimes more than 30%.

It reminds me early days of crypto world - a lot of services that were not used, and only a few won the race.

What Could MCP Look Like in the Future?
MCP’s future looks bright and full of cool possibilities. Experts think MCP will become the universal way AI connects with everything—like a global standard, similar to how the internet got standardized by things like HTTP.

We might see AI work with real-time data from healthcare, finance, or education in ways never done before. Imagine AI that remembers all your health history or helps invest in stocks by accessing real market data live.

MCP could also get smarter with new tech like quantum computing and better ways to keep data private and secure.

In the years ahead, MCP might create a whole economy where developers build and sell special AI connections. It could unlock new jobs and tools that help everyone.

Conclusion
MCP helps AI get smarter by giving it the power to connect, learn, and act in the real world. While many MCP servers exist, only a few are used a lot now. Though the future holds big growth and new tech that could change how AI is part of everyday life.

This exciting technology is still growing fast and could be a game changer in AI in a few years.

Read my other articles
Other posts in this serious:

AI x Web Evolution: How Intelligent Systems Are Powering the Future of the Internet

Maksym Mosiura — Sun, 06 Jul 2025 15:51:20 +0000

The internet has undergone profound shifts—from static HTML pages to dynamic social platforms to decentralized protocols. In parallel, Artificial Intelligence has evolved from rule-based automation to deep neural networks and now to intelligent agents with memory and reasoning.

But what’s most exciting?

Web and AI — are now intertwining and reshaping how we access, filter, and understand information. These two evolutions happened. And we can use the fruits of them now.

This article explores how AI is not just adapting to the next web; how it’s powering it; and how new architectures like Retrieval-Augmented Generation (RAG) make it possible to find and synthesize information faster than ever before.

Let’s briefly revisit the phases of the web:

Each generation of the web unlocks new possibilities. Each time AI evolves with it.

The Rise of AI That Thinks

In early Web2, AI was about predicting your next click (mostly in ads and sales).

Now? It's about answering your question even before you finish asking it, or automatically connecting data across platforms in real-time.

As AI agesnts built with technologies like vector databases, semantic search, and long-term memory, they enables systems to act more like researchers, not just responders.

A core technology behind this is RAG:

RAG allows an AI to search through external and internal knowledge (structured or unstructured) and then generate responses based on both the user query and the retrieved context.

In contrast to traditional AI pipelines for new era of web, RAG:

Understands semantic meaning (not just keywords) - that helps to search quicker, show more precise results;
Finds contextually relevant info across massive datasets - that range results differently than in Google, Yahoo or Bing
Synthesizes personalized, high-quality answers - no need to go thru 5 first websites to find your answer or product
Enables modular and reusable AI components across Web3/Web4 apps - this is about components or micro-frontends that will be used in responses to requester.

Let’s imagine a user interacting with a Web3 dashboard for DAOs and tokens. They ask

“What are the trending governance proposals in DeFi this week?”

A traditional system might return a list of links. This list requires filtering by hand, discovering and making research of each item.

A RAG-powered AI agent does this instead:

Searches vectorized DAO forum content from IPFS or Arweave
Retrieves proposals semantically similar to governance and DeFi
Generates a summary using LLMs like GPT-4

Outputs an up-to-date answer:

There are 3 key proposals active this week in Aave, MakerDAO, and Curve, all focused on yield delegation and cross-chain governance…

The general idea is a simplicity of making analysis to get the final results. AI will do everything for you and you would be able to consume result. Isn't it cool?

Not that fast, rabbit...

The most problematic part here hides in which data will be consumed by AI; how frequently it will be updated; and how AI will prioritize or rank that data.

At first glance, this sounds like a technical detail. In reality it’s a fundamental risk for the next generation of intelligent systems.

What does this mean for users?

It means that if someone creates a new token that suddenly goes viral— even if it's a scam — AI may surface it as a top recommendation or trend. Reason is simple - because the data signals (mentions, volume, velocity) suggest it's important.

And here's the problem:

AI doesn’t understand truth. It understands patterns. That's it for now.

If the training data shows massive engagement, rapid trading, or a flood of social mentions, be sure the AI may interpret that as relevance or value. Even if the token is malicious, unverified, or manipulative, for AI in current iterration it's just enough.

This happens because:

RAG and vector search prioritize semantic relevance, not factual correctness.
Language models are non-opinionated unless explicitly tuned or filtered.
Attention = priority, unless you introduce trust-weighted signals.

So a scam with good marketing can exploit AI's data ingestion the same way it manipulates human psychology.

Moreover, it's not just about tokens in web3, it's about everything!!!

Why This Matters More in Web3

In Web2 scams are filtered by central gatekeepers - app stores, SEO penalties, community reporting (in social media, articles, etc.).

But in Web3, data is decentralized, fast-moving, and often unverifiable. AI agents working across these environments must:

Decide what to trust
Evaluate how much weight to give a source
Possibly cross-reference on-chain vs off-chain data

This becomes even more critical when these agents are acting on your behalf—recommending protocols, approving transactions, or giving financial summaries.

The Fix: Explainability and Signal Hygiene

To prevent AI from blindly promoting noise or scams, we must:

Introduce source ranking layers in vector databases (reputation, historical accuracy, verification).
Add metadata weighting to embeddings (e.g., verified contributor flag).
Use counter-signals (blocklists, anomaly detection) to detect hype vs trust.
Trust only verified Smart Contracts (that can be scanned and parsed to find even hidden scums)

Eventually, we’ll need AI agents that explain their reasoning:

This token is trending due to a large volume of posts in the last 12 hours, but it lacks verified smart contract audits and is flagged by 3 DAO reputational feeds.

Until then, users must remember that AI agents are only as good as the data it eats, and the signals they learn to trust.

What is the next stage?

We’re entering a phase where the web is no longer a place, but a conversation between you, your data, and intelligent agents that live across platforms.

These agents will help us navigate decentralized worlds. Also they will help to extract meaning from fragmented ecosystems and act as companions, advisors, and co-builders

But this is just the beginning... It requires more itterrations to become smarter and trusted.

Other posts in this serious:

RAG: Smarter AI Agents

Maksym Mosiura — Thu, 22 May 2025 03:54:50 +0000

Most developers who works with AI eventually hit the same wall - context. You can pipe tools together, chain AI prompts, or write clever workflows, but at some point, you realize your agent isn’t really thinking. It’s reacting. You need something different.

I hope you used n8n, LangChain, or a similar tool, and you probably created pipelines where each AI step feeds the next. That works for formatting data or guiding workflows. And it is fine for simple agents, but what if your agent needs to remember? What if it needs to learn across conversations? How about adapt to changes? ... or retrieve knowledge like a human?

Before diving into the code, let’s break down AI memory into three simple categories:

Stateless (No Memory):
The agent processes each prompt independently. It’s a great for reformat data, transform or have quick answer. Let's call it "Simple transformation"

Short-Term Memory:
Think of a chatbot that remembers the last couple of interactions. Usually 10-20 last messages. Each chat is isolated. Context is limited to a session window.

Long-Term Memory:
This is more about intelligence. This agent builds an evolving knowledge base across all chats. It ~~try to remember~~ remembers previous user interactions, and connects concepts. This is made possible by vector databases and semantic embeddings.

In this article we will explore how RAG works and what it is, how it differs from traditional AI pipelines, and how you can build your own local memorable agent (using Python and FAISS—fully intelligent memory for offline use or deploying to your own infrastructure).

RAG stands for Retrieval-Augmented Generation.

AI Pipelines vs. RAG

Let’s start with a misconception:

“I already have an AI agent that processes inputs through multiple steps. Isn’t that the same?”

Not quite.

So what’s the Difference?

What is a Traditional AI Pipeline:

steps chained together (for example, summarize → extract → classify)
each step operates on the output of the previous one or wait for multiple
no persistent memory or knowledge base (data come - data leave)
repetition of work if context is lost

That's what people usually see after 10-20 messages. Their context has been lost and they need to remind AI agent about it. It is sad... But that's the cost of simple approach.

RAG Architecture on other hand:

uses a vector database as external memory
retrieves semantically relevant information (instead of guessing from the prompt)
uses both the current prompt and retrieved knowledge to generate a smarter response
memory is structured, persistent, and scalable (...and costly, hahah)

So you might think "How Memory Works in RAG"?
RAG agents don’t store raw text — they store meanings using embeddings. Think of it like associative memory: when you say “I want to automate tasks”, the system doesn’t look for exact matches, it looks for concepts that are semantically close. Each AI is just an LLM on steroids. Where one of the steroid is RAG. So the RAG should consume data, let's call it "memory entry".

Each memory entry includes:

original text
vector (embedding)
metadata (who, when, source, etc.)

This allows fast, flexible search across tens of thousands of interactions without leaking sensitive data to the public. This is very important to users. Moreover "public" here means users that will use the shared between them RAG. So "public" in this context is a group of people, that can be a real public... this article is not about philosophy anyway...

Let’s rather build a basic RAG memory system using:

FAISS — Facebook’s local vector search engine
OpenAI’s embedding API (or you replace it with any public/local embedding model later)

# deps to install
pip install faiss-cpu openai

Now when we have dependencies installed, let's store the memory on a local machine:

import faiss
import openai
import numpy as np

openai.api_key = "YOUR_API_KEY"

# Sample data
texts = [
    "Client wants to automate invoice generation.",
    "Client asks about CRM integration options.",
    "He discussed API for syncing customer data.",
]

# Convert to embeddings
def get_embedding(text):
    response = openai.Embedding.create(
        input=text,
        model="text-embedding-ada-002"
    )
    return np.array(response['data'][0]['embedding'], dtype='float32')

embeddings = np.array([get_embedding(t) for t in texts])
index = faiss.IndexFlatL2(embeddings.shape[1])
index.add(embeddings)

Here is a link to OpenAI embedding intro and OpenAI embedding models.

So when data is stored, we should be able to retrieve it

query = "How do I automate customer data sync?"
query_vec = get_embedding(query)

D, I = index.search(np.array([query_vec]), k=2)

for idx in I[0]:
    print("Relevant memory:", texts[idx])

This request will return us only relevant memory from DB. Output will be:

Relevant memory: He discussed API for syncing customer data.
Relevant memory: Client wants to automate invoice generation.

This is a CORE of your system. Now you are able to pick data by asking human-language questions.

While we just jump on this, let's see why local RAG rocks:

You can easily scale this to 100K+ entries, integrate it with a local LLM like LLama - find one yourself on huggingface. ...or deploy it to your own infrastructure. No cloud dependencies required 💪

Other posts in this serious:

Drill Down AI Agents

Maksym Mosiura — Fri, 09 May 2025 08:31:54 +0000

AI isn't some futuristic buzzword anymore. It's a game-changing technology. But how to use it? We need an agent. The most popular agents at the beginning of 2025 were: Chat GPT, Siri, Google Assistant, Perplexity, IBM Watson and a couple of more. And the number of such quickly growing with new names like DeepSeek and Manus.

These agents are for general purposes or for “research” as called now. They solve general problems. Our goal is to build more specific agents - agents which can solve user’s issues in the environment of a specific company.
These custom AI agents are like having a superhero team of digital assistants that can do things traditional automation can only dream about.

The Three Superpowers of AI Agents:

Adaptability: Smart Enough to Roll with the Punches
Remember those old automation tools that would break the moment something unexpected happened? Forget that! AI agents are like digital chameleons. They can adapt and get smarter. Moreover, they can save a context of a specific user’s conversation and use it later for different purposes: pushing to act, provide some personalized information, request some details for suggestions or even predict behaviour.
It actually learns what customers like, remembers their preferences, and becomes more helpful with every interaction. Can it be reached with any other tool? Definitely, no.

Scalability: Handling Massive Workloads Without Breaking a Sweat
Like any modern software, AI agents can be scaled. The scaling depends on which kind of agent is built.

Humans have limits. AI agents laugh in the face of massive workloads. Their limits are easily extendable.

Example: Take fraud detection. An AI agent can scan through thousands of financial transactions in a second than a team of accountants could in a month. And it does this with laser-sharp accuracy, catching suspicious patterns that might slip past human eyes.
This means our AI agents can assist us with provided data or use such from provided resources. Scalability allows these agents to understand how complex the request is and run it in the appropriate environment.

Autonomous Decision-Making: No Supervision Required
Here's the really cool part: AI agents don't need constant babysitting. They can make independent decisions based on real-time data and past experience.

Example: Stock-trading AI. It can watch the market 24/7 and make trading decisions. AI can track how good it is during a certain time and decide when to make trades and when to do nothing. While human traders are sleeping, grabbing coffee, or getting distracted, these AI agents are working non-stop, analyzing data, spotting opportunities, and taking actions.

AI agents aren't just a technology upgrade. They're a complete rethinking of how we approach automation, decision-making, and problem-solving. Businesses that embrace these technologies aren't just staying current - they're staying ahead.

So, what the core component of AI Agents?

An AI agent is a system that perceives its environment using sensors like input, API, envs, cache, and its LLM. The agent processes this information and acts.

In order to build the intelligent agent, it should have the ability to:

perceive ("understand") its environment
consume, process, and save information
act in this environment
save and learn from experience
analyse and improve performance

Any AI agent requires some helpers. Without the helpers, the agent can't work clearly or provide adequate results. Let's call them components and here they are:

LLMs
APIs
Tools
Memory
Cache
Other Agents

In other words, these are core components of an AI agent, where
LLM → is a brain. It processes inputs, understands context, and generates responses. Memory/Cache → stores tokens, context, past interactions, user data, or learned information. Tools/APIs → external functionality that can be used. Other Agents → to process or preprocess data that will be consumed by the main agent.

Other posts in this serious: