From Blueprint to Build - The Design and Planning Phase in Data Engineering

Overview

The design and planning phase of a data engineering project is crucial for laying out the foundation of a successful and scalable solution. This phase ensures that the architecture is strategically aligned with business objectives, optimizes resource utilization, and mitigates potential risks.

• Follow this GitHub repo during the presentation: (Give it a star)

👉 https://github.com/ozkary/data-engineering-mta-turnstile

• Read more information on my blog at:

👉 https://www.ozkary.com/2023/03/data-engineering-process-fundamentals.html

YouTube Video

Video Agenda

In this session, we embark on the next chapter of our data journey, delving into the critical Design and Planning Phase. As we transition from discovery to design, we'll unravel the intricacies of:

System Design and Architecture:

• Understanding the foundational principles that shape a robust and scalable data system.

  Data Pipeline and Orchestration:

• Uncovering the essentials of designing an efficient data pipeline and orchestrating seamless data flows.

  Source Control and Deployment:

• Navigating the best practices for source control, versioning, and deployment strategies.

  CI/CD in Data Engineering:

• Implementing Continuous Integration and Continuous Deployment (CI/CD) practices for agility and reliability.

  Docker Container and Docker Hub:

• Harnessing the power of Docker containers and Docker Hub for containerized deployments.

  Cloud Infrastructure with IaC:

• Exploring technologies for building out cloud infrastructure using Infrastructure as Code (IaC), ensuring efficiency and consistency.

Why Join:

• Gain insights into designing scalable and efficient data systems.

• Learn best practices for cloud infrastructure and IaC.

• Discover the importance of data pipeline orchestration and source control.

• Explore the world of CI/CD in the context of data engineering.

• Unlock the potential of Docker containers for your data workflows.

Some of the technologies that we will be covering:

• Cloud Infrastructure
• Data Pipelines
• GitHub and Actions
• VSCode
• Docker and Docker Hub
• Terraform

Presentation

Data Engineering Overview

A Data Engineering Process involves executing steps to understand the problem, scope, design, and architecture for creating a solution. This enables ongoing big data analysis using analytical and visualization tools.

Topics

• Importance of Design and Planning
• System Design and Architecture
• Data Pipeline and Orchestration
• Source Control and CI/CD
• Docker Containers
• Cloud Infrastructure with IaC

Follow this project: Give a star

👉 Data Engineering Process Fundamentals

Importance of Design and Planning

The design and planning phase of a data engineering project is crucial for laying out the foundation of a successful and scalable solution. This phase ensures that the architecture is strategically aligned with business objectives, optimizes resource utilization, and mitigates potential risks.

Foundational Areas

• Designing the data pipeline and technology specifications like flows, coding language, data governance and tools
• Define the system architecture like cloud services for scalability, data platform
• Source control and deployment automation with CI/CD
• Using Docker containers for environment isolation to avoid deployment issues
• Infrastructure automation with Terraform or cloud CLI tools
• System monitor, notification and recovery

System Design and Architecture

In a system design, we need to clearly define the different technologies that should be used for each area of the solution. It includes the high-level system architecture, which defines the different components and their integration.

• The design outlines the technical solution, including system architecture, data integration, flow orchestration, storage platforms, and data processing tools. It focuses on defining technologies for each component to ensure a cohesive and efficient solution.

• A system architecture is a critical high-level design encompassing various components such as data sources, ingestion resources, workflow orchestration, storage, transformation services, continuous ingestion, validation mechanisms, and analytics tools.

Data Pipeline and Orchestration

A data pipeline is basically a workflow of tasks that can be executed in Docker containers. The execution, scheduling, managing and monitoring of the pipeline is referred to as orchestration. In order to support the operations of the pipeline and its orchestration, we need to provision a VM and data lake, and monitor cloud resources.

• This can be code-centric, leveraging languages like Python, SQL
• Or a low-code approach, utilizing tools such as Azure Data Factory, which provides a turn-key solution
• Monitor services enable us to track telemetry data to support operational requirements
• Docker Hub, GitHub can be used for the CI/CD process and deployed our code-centric solutions
• Scheduling, recovering from failures and dashboards are essentials for orchestration
• Low-code solutions , like data factory, can also be used

Source Control - CI/CD

Implementing source control practices alongside Continuous Integration and Continuous Delivery (CI/CD) pipelines is vital for facilitating agile development. This ensures efficient collaboration, change tracking, and seamless code deployment, crucial for addressing ongoing feature changes, bug fixes, and new environment deployments.

• Systems like Git facilitates effective code and configuration file management, enabling collaboration and change tracking.
• Platforms such as GitHub enhance collaboration by providing a remote repository for sharing code.
• CI involves integrating code changes into a central repository, followed by automated build and test processes to validate changes and provide feedback.
• CD automates the deployment of code builds to various environments, such as staging and production, streamlining the release process and ensuring consistency across environments.

Docker Container and Docker Hub

Docker proves invaluable for our data pipelines by providing self-contained environments with all necessary dependencies. With Docker Hub, we can effortlessly distribute pipeline images, facilitating swift and reliable provisioning of new environments.

• Docker containers streamline the deployment process by encapsulating application and dependency configurations, reducing runtime errors.
• Containerizing data pipelines ensures reliability and portability by packaging all necessary components within a single container image.
• Docker Hub serves as a centralized container registry, enabling seamless image storage and distribution for streamlined environment provisioning and scalability.

Cloud Infrastructure with IaC

Infrastructure automation is crucial for maintaining consistency, scalability, and reliability across environments. By defining infrastructure as code (IaC), organizations can efficiently provision and modify cloud resources, mitigating manual errors.

• Define infrastructure configurations as code, ensuring consistency across environments.
• Easily scale resources up or down to meet changing demands with code-defined infrastructure.
• Reduce manual errors and ensure reproducibility by automating resource provisioning and management.
• Track infrastructure changes under version control, enabling collaboration and ensuring auditability.
• Track infrastructure state, allowing for precise updates and minimizing drift between desired and actual configurations.

Summary

The design and planning phase of a data engineering project sets the stage for success. From designing the system architecture and data pipelines to implementing source control, CI/CD, Docker, and infrastructure automation with Terraform, every aspect contributes to efficient and reliable deployment. Infrastructure automation, in particular, plays a critical role by simplifying provisioning of cloud resources, ensuring consistency, and enabling scalability, ultimately leading to a robust and manageable data engineering system.

Upcoming Talks:

Join us for subsequent sessions in our Data Engineering Process Fundamentals series, where we will delve deeper into specific facets of data engineering, exploring topics such as data modeling, pipelines, and best practices in data governance.

This presentation is based on the book, Data Engineering Process Fundamentals, which provides a more comprehensive guide to the topics we'll cover. You can find all the sample code and datasets used in this presentation on our popular GitHub repository Introduction to Data Engineering Process Fundamentals.

Thanks for reading! 😊 If you enjoyed this post and would like to stay updated with our latest content, don’t forget to follow us. Join our community and be the first to know about new articles, exclusive insights, and more!

• Google Developer Group
• GitHub
• Twitter
• YouTube
• BlueSky

👍 Originally published by ozkary.com

From Raw Data to Roadmap: The Discovery Phase in Data Engineering Process Fundamentals

Overview

The discovery process involves identifying the problem, analyzing data sources, defining project requirements, establishing the project scope, and designing an effective architecture to address the identified challenges.

In this session, we will delve into the essential building blocks of data engineering, placing a spotlight on the discovery process. From framing the problem statement to navigating the intricacies of exploratory data analysis (EDA) using Python, VSCode, Jupyter Notebooks, and GitHub, you'll gain a solid understanding of the fundamental aspects that drive effective data engineering projects.

DevFest Series Data Engineering Process Fundamentals Series

• Follow this GitHub repo during the presentation: (Give it a star)

👉 GitHub Repo

Jupyter Notebook

👉 Jupyter Notebook

• Data engineering Series:

👉 Blog Series

👉 Data Engineering Book on Amazon

YouTube Video

Video Agenda

In this session, we will delve into the essential building blocks of data engineering, placing a spotlight on the discovery process. From framing the problem statement to navigating the intricacies of exploratory data analysis (EDA), data modeling using Python, VS Code, Jupyter Notebooks, SQL, and GitHub, you'll gain a solid understanding of the fundamental aspects that drive effective data engineering projects.

1. Introduction:

   • The "Why": We'll discuss why understanding your data upfront is crucial for success.
   • The Problem: We'll introduce a real-world problem that will guide our exploration.

2. Data Loading and Preparation:

   • Loading: We'll demonstrate how to efficiently load data from an online source directly into our workspace.
   • Structuring: We'll prepare the loaded data for analysis, making it easy to work with.

3. Exploratory Data Analysis (EDA):

   • First Look: We'll learn how to quickly generate and interpret summary statistics for our data.
   • The Story: We'll use these statistics to understand the data's characteristics and identify any red flags or anomalies.

4. Data Cleaning and Modeling:

   • Cleaning: We'll identify and handle common data issues like missing values and inconsistencies.
   • Modeling: We'll organize our data into separate tables for dimensions (descriptive attributes) and facts (measurable values).

5. Visualization and Real-World Application:

   • Bringing it to Life: We'll create charts to visualize the data and find patterns.
   • Solving the Problem: We'll apply the insights gained to address our original problem and discuss practical solutions.

Key Takeaways:

• Mastery of the foundational aspects of data engineering.
• Hands-on experience with EDA techniques, emphasizing the discovery phase.
• Appreciation for the value of a code-centric approach in the data engineering discovery process.

Upcoming Talks:

Join us for subsequent sessions in our Data Engineering Process Fundamentals series, where we will delve deeper into specific facets of data engineering, exploring topics such as data modeling, pipelines, and best practices in data governance.

This presentation is based on the book, "Data Engineering Process Fundamentals," which provides a more comprehensive guide to the topics we'll cover. You can find all the sample code and datasets used in this presentation on our popular GitHub repository.

Presentation

Data Engineering Overview

A Data Engineering Process involves executing steps to understand the problem, scope, design, and architecture for creating a solution. This enables ongoing big data analysis using analytical and visualization tools.

Topics

• Importance of the Discovery Process
• Setting the Stage - Technologies
• Exploratory Data Analysis (EDA)
• Code-Centric Approach
• Version Control
• Real-World Use Case

Follow this project: Give a star

👉 Data Engineering Process Fundamentals

Importance of the Discovery Process

The discovery process involves identifying the problem, analyzing data sources, defining project requirements, establishing the project scope, and designing an effective architecture to address the identified challenges.

• Clearly document the problem statement to understand the challenges the project aims to address.
• Make observations about the data, its structure, and sources during the discovery process.
• Define project requirements based on the observations, enabling the team to understand the scope and goals.
• Clearly outline the scope of the project, ensuring a focused and well-defined set of objectives.
• Use insights from the discovery phase to inform the design of the solution, including data architecture.
• Develop a robust project architecture that aligns with the defined requirements and scope.

Setting the Stage - Technologies

To set the stage, we need to identify and select the tools that can facilitate the analysis and documentation of the data. Here are key technologies that play a crucial role in this stage:

• Python: A versatile programming language with rich libraries for data manipulation, analysis, and scripting.

Use Cases: Data download, cleaning, exploration, and scripting for automation.

• Jupyter Notebooks: An interactive tool for creating and sharing documents containing live code, visualizations, and narrative text.

Use Cases: Exploratory data analysis, documentation, and code collaboration.

• Visual Studio Code: A lightweight, extensible code editor with powerful features for source code editing and debugging.

Use Cases: Writing and debugging code, integrating with version control systems like GitHub.

• SQL (Structured Query Language): A domain-specific language for managing and manipulating relational databases.

Use Cases: Querying databases, data extraction, and transformation.

Exploratory Data Analysis (EDA)

EDA is our go-to method for downloading, analyzing, understanding and documenting the intricacies of the datasets. It's like peeling back the layers of information to reveal the stories hidden within the data. Here's what EDA is all about:

• EDA is the process of analyzing data to identify patterns, relationships, and anomalies, guiding the project's direction.

• Python and Jupyter Notebook collaboratively empower us to download, describe, and transform data through live queries.

• Insights gained from EDA set the foundation for informed decision-making in subsequent data engineering steps.

• Code written on Jupyter Notebook can be exported and used as the starting point for components for the data pipeline and transformation services.

Code-Centric Approach

A code-centric approach, using programming languages and tools in EDA, helps us understand the coding methodology for building data structures, defining schemas, and establishing relationships. This robust understanding seamlessly guides project implementation.

• Code delves deep into data intricacies, revealing integration and transformation challenges often unclear with visual tools.

• Using code taps into Pandas and Numpy libraries, empowering robust manipulation of data frames, establishment of loading schemas, and addressing transformation needs.

• Code-centricity enables sophisticated analyses, covering aggregation, distribution, and in-depth examinations of the data.

• While visual tools have their merits, a code-centric approach excels in hands-on, detailed data exploration, uncovering subtle nuances and potential challenges.

Version Control

Using a tool like GitHub is essential for effective version control and collaboration in our discovery process. GitHub enables us to track our exploratory code and Jupyter Notebooks, fostering collaboration, documentation, and comprehensive project management. Here's how GitHub enhances our process:

• Centralized Tracking: GitHub centralizes tracking and managing our exploratory code and Jupyter Notebooks, ensuring a transparent and organized record of our data exploration.

• Sharing: Easily share code and Notebooks with team members on GitHub, fostering seamless collaboration and knowledge sharing.

• Documentation: GitHub supports Markdown, enabling comprehensive documentation of processes, findings, and insights within the same repository.

• Project Management: GitHub acts as a project management hub, facilitating CI/CD pipeline integration for smooth and automated delivery of data engineering projects.

Summary: The Power of Discovery

By mastering the discovery phase, you lay a strong foundation for successful data engineering projects. A thorough understanding of your data is essential for extracting meaningful insights.

• Understanding Your Data: The discovery phase is crucial for understanding your data's characteristics, quality, and potential.
• Exploratory Data Analysis (EDA): Use techniques to uncover patterns, trends, and anomalies.
• Data Profiling: Assess data quality, identify missing values, and understand data distributions.
• Data Cleaning: Address data inconsistencies and errors to ensure data accuracy.
• Domain Knowledge: Leverage domain expertise to guide data exploration and interpretation.
• Setting the Stage: Choose the right language and tools for efficient data exploration and analysis.

The data engineering discovery process involves defining the problem statement, gathering requirements, and determining the scope of work. It also includes a data analysis exercise utilizing Python and Jupyter Notebooks or other tools to extract valuable insights from the data. These steps collectively lay the foundation for successful data engineering endeavors.

Thanks for reading! 😊 If you enjoyed this post and would like to stay updated with our latest content, don’t forget to follow us. Join our community and be the first to know about new articles, exclusive insights, and more!

• Google Developer Group
• GitHub
• Twitter
• YouTube
• BlueSky

👍 Originally published by ozkary.com

Discover AI Agents - A Primer's Guide July 2025

Overview

What’s the AI agent mystique? Are they just chatbots with automation? What makes them different—and why does it matter?

This presentation breaks it down from the ground up. We’ll explore what truly sets AI agents apart—how they perceive, reason, and act with autonomy across industries ranging from healthcare to retail to logistics. You'll walk away with a clear understanding of what an agent is, how it works, and what it takes to build one.

Whether you’re a developer, strategist, or simply curious, this session is your entry point to one of the most transformative ideas in AI today.

#BuildWithAI Series

YouTube Video

GitHub Repo

Video Agenda:

• What is an AI Agent?
• Autonomy Advantage: How AI Agents Go Beyond Automation
• The Agent’s Secret Power
• Model Context Protocol (MCP): The Key to Tool Integration
• How Does an Agent Talk MCP?
• Benefits of MCP for AI Agents
• Shape Agent Behavior Through Prompting

Presentation

What is an AI Agent?

An AI agent is a software robot that observes what’s happening, figures out what to do, and then does it—all without a human needing to guide every step.

Manufacturing Setting:

• Monitors sensor data in real time, comparing each new reading against control limits and recent patterns to detect drift, anomalies, or rule violations.
• Decides what needs to happen next—whether that’s pausing production, flagging maintenance, or adjusting inputs to keep the process stable.
• Acts without waiting for instructions, logging the event, alerting staff, or triggering automated workflows across connected systems.

"Now, you might wonder—how’s this different from just traditional automation?"

Autonomy Advantage: How AI Agents Go Beyond Automation

Unlike scripted automation, an AI agent brings autonomy—acting with awareness, judgment, and initiative. It doesn’t just execute commands—it thinks.

• Perception Observes real-time data from sensors, machines, and systems—just like a human operator watching a dashboard—but at higher speed and scale.

• Reasoning Analyzes trends and patterns from recent data (its reasoning window) to assess stability, detect anomalies, or anticipate breakdowns—just like an engineer interpreting a control chart.

• Action Takes initiative by triggering responses: adjusting inputs, alerting staff, logging events, or even halting production—without waiting for permission.

But, what powers this autonomy?

The Agent’s Secret Power

An AI agent doesn’t just automate—it senses, thinks, and acts on its own. These core technologies are what give it autonomy.

Manufacturing Setting:

• Perception Ingests real-time sensor data and stores recent readings in a reasoning window for short-term memory.
• Reasoning Uses an LLM (like Gemini) to analyze trends, detect rule violations, and interpret process behavior—beyond rigid logic.
• Action Executes commands using predefined tools via MCP—like notifying staff, triggering scripts, or calling APIs.

Wait, what are MCP tools?

Model Context Protocol (MCP): The Key to Tool Integration

MCP is a communication framework that lets AI agents use tools—like APIs, databases, or notifications—by expressing intent in structured language.

• Triggering a Notification The agent says: @notify: supervisor_alert("Vibration spike detected on motor_3A") MCP delivers a formatted message via email, SMS, or system alert.

POST /alerts/send
Content-Type: application/json

{
  "recipient": "supervisor_team",
  "message": "Vibration spike detected on motor_3A",
  "priority": "high"
}

tool: notify_supervisor
description: Sends an alert message to the assigned supervisor team
parameters:
  - name: message
    type: string
    required: true
    description: The alert message to send
example_call: "@notify: supervisor_alert(\"Vibration spike detected on motor_3A\")"
execution:
  type: webhook
  method: POST
  endpoint: https://factory.opsys.com/alerts/send
  payload_mapping:
    recipient: "supervisor_team"
    message: "{{message}}"
    priority: "high"

How Does the Agent Understand MCP?

When an agent makes a decision, it doesn’t call a function directly—it declares intent using a structured phrase. MCP translates that intent into a real-world action by matching it to a predefined tool. Essentially, reading the tool metadata as a prompt.

Agent says:

@notify: supervisor_alert("Vibration spike detected on motor_3A")

In Action:

• Agent emits intent using MCP syntax, @notify: supervisor_alert("Vibration spike detected on motor_3A")
• MCP matches the function name (supervisor_alert) to a registered tool.
• Execution Engine constructs the proper HTTP request using metadata, endpoint URL, method, headers, authentication.
• Action is performed: supervisor is notified via the external system.

The agent just describes what it needed to happen. MCP handles the how.

Benefits of MCP for AI Agents

MCP gives AI agents the flexibility and intelligence to grow beyond fixed automation—enabling them to explore, understand, and apply tools in dynamic environments.

• *Dynamic Tool Discovery:- Agents can learn about and use new tools without explicit programming.
• *Human-like Tool Usage:- Agents leverage tools based on their "understanding" of the tool's purpose and capabilities, similar to how a human learns to use a new application.
• *Enhanced Functionality & Adaptability:- Unlocks a vast ecosystem of capabilities for autonomous agents.

To act effectively, agents also need character—a defined role, a point of view, a way to think.

Shape Agent Behavior Through Prompting

Textual instructions or context provided to guide the agent's behavior and reasoning. They are crucial for controlling and directing autonomous agents.

• System Prompts Define the agent’s identity, role, tone, and reasoning strategy. This is its operating character—guiding how it thinks across all interactions. > Example: “You are a manufacturing agent that monitors vibration data and applies SPC rules to detect risk.”

• User/Agent Prompts Deliver instructions at the moment. These guide the agent’s short-term focus and task-specific reasoning. > Example: “Analyze this new sample and let me know if we’re trending toward a shutdown.”

How do I get started?

Getting Started with AI Agents: The Tech Stack

To build your first AI agent, these tools offer a powerful foundation—though not the only options, they represent a well-integrated, production-ready ecosystem:

• LangChain: Core framework for integrating tools, memory, vector databases, and APIs. Think of it as the foundation that gives your agent capabilities.

• LangGraph Adds orchestration and state management by turning your LangChain components into reactive, stateful workflows—ideal for agents that need long-term memory and conditional behavior.

• LangSmith: Monitoring and evaluation suite to observe, debug, and improve your agents—see how prompts, memory, and tools interact across sessions.

• n8n: No-code orchestration platform that lets you deploy agents into real-world business systems—perfect for automation without touching code.

Thanks for reading! 😊 If you enjoyed this post and would like to stay updated with our latest content, don’t forget to follow us. Join our community and be the first to know about new articles, exclusive insights, and more!

• Google Developer Group
• GitHub
• Twitter
• YouTube
• BlueSky

👍 Originally published by ozkary.com

Autonomous AI Agent: A Primer's Guide - June 2025

Overview

What’s the AI agent mystique? Are they just chatbots with automation? What makes them different—and why does it matter?

This presentation breaks it down from the ground up. We’ll explore what truly sets AI agents apart—how they perceive, reason, and act with autonomy across industries ranging from healthcare to retail to logistics. You'll walk away with a clear understanding of what an agent is, how it works, and what it takes to build one.

Whether you’re a developer, strategist, or simply curious, this session is your entry point to one of the most transformative ideas in AI today.

#BuildWithAI Series

#June 2025 Presentation

YouTube Video

GitHub Repo

Video Agenda:

• What is an AI Agent?
• Autonomy Advantage: How AI Agents Go Beyond Automation
• The Agent’s Secret Power
• Model Context Protocol (MCP): The Key to Tool Integration
• How Does an Agent Talk MCP?
• Benefits of MCP for AI Agents
• Shape Agent Behavior Through Prompting

Presentation

What is an AI Agent?

An AI agent is a software robot that observes what’s happening, figures out what to do, and then does it—all without a human needing to guide every step.

Manufacturing Setting:

• Monitors sensor data in real time, comparing each new reading against control limits and recent patterns to detect drift, anomalies, or rule violations.
• Decides what needs to happen next—whether that’s pausing production, flagging maintenance, or adjusting inputs to keep the process stable.
• Acts without waiting for instructions, logging the event, alerting staff, or triggering automated workflows across connected systems.

"Now, you might wonder—how’s this different from just traditional automation?"

Autonomy Advantage: How AI Agents Go Beyond Automation

Unlike scripted automation, an AI agent brings autonomy—acting with awareness, judgment, and initiative. It doesn’t just execute commands—it thinks.

• Perception Observes real-time data from sensors, machines, and systems—just like a human operator watching a dashboard—but at higher speed and scale.

• Reasoning Analyzes trends and patterns from recent data (its reasoning window) to assess stability, detect anomalies, or anticipate breakdowns—just like an engineer interpreting a control chart.

• Action Takes initiative by triggering responses: adjusting inputs, alerting staff, logging events, or even halting production—without waiting for permission.

But, what powers this autonomy?

The Agent’s Secret Power

An AI agent doesn’t just automate—it senses, thinks, and acts on its own. These core technologies are what give it autonomy.

Manufacturing Setting:

• Perception Ingests real-time sensor data and stores recent readings in a reasoning window for short-term memory.
• Reasoning Uses an LLM (like Gemini) to analyze trends, detect rule violations, and interpret process behavior—beyond rigid logic.
• Action Executes commands using predefined tools via MCP—like notifying staff, triggering scripts, or calling APIs.

Wait, what are MCP tools?

Model Context Protocol (MCP): The Key to Tool Integration

MCP is a communication framework that lets AI agents use tools—like APIs, databases, or notifications—by expressing intent in structured language.

• Triggering a Notification The agent says: @notify: supervisor_alert("Vibration spike detected on motor_3A") MCP delivers a formatted message via email, SMS, or system alert.

POST /alerts/send
Content-Type: application/json

{
  "recipient": "supervisor_team",
  "message": "Vibration spike detected on motor_3A",
  "priority": "high"
}

tool: notify_supervisor
description: Sends an alert message to the assigned supervisor team
parameters:
  - name: message
    type: string
    required: true
    description: The alert message to send
example_call: "@notify: supervisor_alert(\"Vibration spike detected on motor_3A\")"
execution:
  type: webhook
  method: POST
  endpoint: https://factory.opsys.com/alerts/send
  payload_mapping:
    recipient: "supervisor_team"
    message: "{{message}}"
    priority: "high"

How Does the Agent Understand MCP?

When an agent makes a decision, it doesn’t call a function directly—it declares intent using a structured phrase. MCP translates that intent into a real-world action by matching it to a predefined tool. Essentially, reading the tool metadata as a prompt.

Agent says:

@notify: supervisor_alert("Vibration spike detected on motor_3A")

In Action:

• Agent emits intent using MCP syntax, @notify: supervisor_alert("Vibration spike detected on motor_3A")
• MCP matches the function name (supervisor_alert) to a registered tool.
• Execution Engine constructs the proper HTTP request using metadata, endpoint URL, method, headers, authentication.
• Action is performed: supervisor is notified via the external system.

The agent just describes what it needed to happen. MCP handles the how.

Benefits of MCP for AI Agents

MCP gives AI agents the flexibility and intelligence to grow beyond fixed automation—enabling them to explore, understand, and apply tools in dynamic environments.

• *Dynamic Tool Discovery:- Agents can learn about and use new tools without explicit programming.
• *Human-like Tool Usage:- Agents leverage tools based on their "understanding" of the tool's purpose and capabilities, similar to how a human learns to use a new application.
• *Enhanced Functionality & Adaptability:- Unlocks a vast ecosystem of capabilities for autonomous agents.

To act effectively, agents also need character—a defined role, a point of view, a way to think.

Shape Agent Behavior Through Prompting

Textual instructions or context provided to guide the agent's behavior and reasoning. They are crucial for controlling and directing autonomous agents.

• System Prompts Define the agent’s identity, role, tone, and reasoning strategy. This is its operating character—guiding how it thinks across all interactions. > Example: “You are a manufacturing agent that monitors vibration data and applies SPC rules to detect risk.”

• User/Agent Prompts Deliver instructions at the moment. These guide the agent’s short-term focus and task-specific reasoning. > Example: “Analyze this new sample and let me know if we’re trending toward a shutdown.”

How do I get started?

Getting Started with AI Agents: The Tech Stack

To build your first AI agent, these tools offer a powerful foundation—though not the only options, they represent a well-integrated, production-ready ecosystem:

• LangChain: Core framework for integrating tools, memory, vector databases, and APIs. Think of it as the foundation that gives your agent capabilities.

• LangGraph Adds orchestration and state management by turning your LangChain components into reactive, stateful workflows—ideal for agents that need long-term memory and conditional behavior.

• LangSmith: Monitoring and evaluation suite to observe, debug, and improve your agents—see how prompts, memory, and tools interact across sessions.

• n8n: No-code orchestration platform that lets you deploy agents into real-world business systems—perfect for automation without touching code.

Thanks for reading! 😊 If you enjoyed this post and would like to stay updated with our latest content, don’t forget to follow us. Join our community and be the first to know about new articles, exclusive insights, and more!

• Google Developer Group
• GitHub
• Twitter
• YouTube
• BlueSky

👍 Originally published by ozkary.com

Restore VS Code After Windows Updates Remove It

Overview

Windows updates are meant to improve system stability, but occasionally, they restructure important folders, leading to unexpected issues. One problem some users have encountered is VS Code files being moved to a mysterious _ folder inside its installation directory. If this happens to you, don’t worry you can restore VS Code easily with a simple script!

Understanding the Issue

After certain Windows updates, your VS Code installation folder (C:\Users\{YourUsername}\AppData\Local\Programs\Microsoft VS Code) may contain a subfolder called _. Instead of properly maintaining the installation structure, the update isolates essential VS Code files within this _ folder, making it difficult for the application to launch correctly.

How to Fix It Manually

1. Open File Explorer and navigate to:

C:\Users\{YourUsername}\AppData\Local\Programs\Microsoft VS Code

1. If you see a _ folder, open it.
2. Move all its contents back to the parent directory.
3. Restart VS Code to ensure everything works normally.

Automate the Fix with a Script

If you want a one-click solution, this batch script will detect the misplaced files, prompt you for confirmation, and move them back automatically:

@echo off
setlocal

:: ==============================================================
:: Restore VS Code After Windows Updates Remove It
:: ==============================================================
:: Some Windows updates mistakenly move VS Code files into a "_" 
:: subfolder inside its main installation directory. This script 
:: checks if the folder exists and prompts the user before restoring 
:: the files to the correct location.
:: ==============================================================

:: Define the VS Code installation directory
set "vscodeDir=%USERPROFILE%\AppData\Local\Programs\Microsoft VS Code"

:: Define the misplaced folder path
set "underscoreDir=%vscodeDir%\_"

:: Check if the "_" directory exists
if not exist "%underscoreDir%" (
 echo No misplaced files found. Nothing to fix!
 exit /b
)

:: Prompt user for confirmation
echo A misplaced folder ("_") was found inside the VS Code installation directory.
set /p userInput=Do you want to move its contents back to the parent folder? (Y/N): 

:: Convert input to uppercase to handle lowercase entries
if /I not "%userInput%"=="Y" (
 echo Operation canceled.
 exit /b
)

:: Move files back to the parent directory
echo Moving files back to parent directory...
move "%underscoreDir%\*" "%vscodeDir%"
echo Done! The misplaced files have been restored.

endlocal

How to Use the Script

• Copy the code into Notepad.
• Save it as restore_vscode.bat (make sure it’s saved as All Files, not a .txt file).
• Run the script by right-clicking and selecting Run as administrator.
• If the _ folder exists, the script will ask for confirmation before moving the files.
• Press Y and hit Enter to restore your VS Code files.

Automating the Process for Future Updates

If you find this problem recurring after every update, consider automating the fix:

• Task Scheduler: Set up a scheduled task to run this script after each Windows update.
• Startup Folder: Place the script in the Windows startup directory so it runs on boot.

By using this script, you’ll save time and frustration, ensuring VS Code remains fully functional after every Windows update.

Thanks for reading and follow me for more technical articles, videos and podcasts

• GitHub
• Twitter
• YouTube
• BlueSky

👍 Originally published by ozkary.com