DOCSEARCHbyAlgolia
Submit Docs

Jinhyuk Kim's Engineering Blog

website·Indexed 30 days ago

https://blog.jinhyuk.kim

A collection of technical projects and learning notes covering the Drawing Robot Platform (DRP), a collaborative robot integration platform (MRC), and an on-premise ERP system built with FastAPI, Next.js, and LLMs. Includes detailed engineering records on robot coordinate systems, multi-vendor architectures, hybrid search with pgvector, and a 2026 AI certification roadmap for Azure AI-103 and AWS MLA-C01.

Tokens
29.2K
Snippets
72
Records
161
Agent score
50%

What's inside Jinhyuk Kim Blog

  1. Overview of Azure AI-103 and AWS MLA-C01 Certifications

    For developers looking to prove expertise in both AI application development and ML operations, the following certifications are recommended:

    • Azure AI-103 (Developing AI Apps and Agents on Azure): Focuses on GenAI apps, RAG, and multi-agent systems using Microsoft Foundry. (120 min, 700 passing score, available in Korean).
    • AWS MLA-C01 (AWS ML Engineer – Associate): Focuses on SageMaker, pipelines, deployment, and monitoring. Approximately 46% of the domain covers MLOps. (130 min, 65 questions, 720 passing score, cost: $150).

    Combining these two covers both the 'user/developer' side (Azure) and the 'operator/MLOps' side (AWS).

  2. Overview of the Image-to-Robot Command Pipeline

    The pipeline transforms a line-drawing PNG URL into a list of RobotCommand objects through four sequential stages:

    1. Download & Preprocessing: Fetches the image and converts it to a binary image using Otsu or Adaptive thresholding.
    2. Vectorization: Converts the binary image into a list of paths (List[List[(x, y)]]) using a 4-stage fallback mechanism.
    3. Path Optimization: Simplifies paths using Douglas-Peucker, resamples points, and sorts the drawing order using Nearest Neighbor (NN) and 2-opt algorithms to minimize travel distance.
    4. Coordinate Transformation: Maps pixel coordinates to millimeters (mm), clamps them to an A4 safe area, and generates penUp, penDown, and moveL commands.

  3. Overview of AI-103 and MLA-C01 Certifications

    In 2026, the AI certification landscape shifted toward GenAI, RAG, and Agents. The two primary Associate-level certifications are:

    1. AI-103 (Developing AI Apps and Agents on Azure): Focuses on the developer perspective—how to use models to build applications and agents using Microsoft Foundry and Python SDK.
    2. MLA-C01 (AWS Certified Machine Learning Engineer – Associate): Focuses on the engineering perspective—how to operate and deploy ML pipelines using Amazon SageMaker and Bedrock.

  4. MRC Collaborative Robot Platform Overview

    MRC is an open, hardware-agnostic, AI-native platform designed to control heterogeneous collaborative robots from multiple vendors (A, B, C, D, E, and F) through a single interface. It aims to combine ROS2 and AI orchestration into a single layer, allowing LLMs and Agents to plan and execute robot actions via a node-based visual editor.

  5. DRP System Architecture Overview

    The DRP system is designed to remotely operate robot arms (JAKA) deployed across multiple on-premise sites. Each site consists of a tablet, an on-premise server, and a JAKA robot. The system uses a Python (FastAPI) backend and a Flutter frontend, integrated via a monorepo. Due to inconsistent internet quality and firewall restrictions, site servers are not directly accessible from the outside and are managed via Tailscale VPN using a pull-model monitoring system.

  6. Implement a Multi-Vendor Collaborative Robot Architecture using Capability Mixins

    To maintain a lean Core Abstract Base Class (ABC) while supporting diverse vendor capabilities, use an opt-in Mixin pattern. Define specific capabilities as Mixins (e.g., HasImpedanceControl, HasIO) that adapters can implement. This allows node editors to reflect these mixins and dynamically expose available options based on the robot's capabilities.

  7. Implement a 4-Layer Riverpod architecture in Flutter

    To ensure a strict unidirectional dependency flow (Top $\rightarrow$ Bottom), the app implements a 4-layer pattern:

    1. View (ConsumerWidget): Responsible only for rendering. Subscribes to providers via ref.watch(). Contains zero business logic.
    2. Provider (StateNotifier / Notifier): Manages state and actions. Receives user input from the View, calls Services, and processes data into models for the UI.
    3. Service (Business Logic + I/O): Handles external communication. Examples include robot_api_service, ai_image_service, camera_service, and log_service.
    4. External (Backend / Native / Storage): The actual external interfaces such as FastAPI, S3, JNI native (Potrace), SharedPreferences, or Camera plugins.

  8. Best practices for designing a Python RPC-based worker system for version isolation

    When isolating incompatible Python versions (e.g., a legacy 3.5 SDK and a modern 3.10+ server) using a worker-based architecture, implement the following design patterns to ensure stability and maintainability:

    1. Contract-First API: Define the RPC contract using OpenAPI or JSON Schema. Use code generation to keep the main server and worker specifications synchronized.
    2. Distributed Tracing: Propagate a trace_id through RPC headers so that logs from both the main server and the isolated worker can be correlated.
    3. Side-Channel for Large Payloads: Avoid sending large data (such as trajectories or camera frames) via RPC. Instead, use shared volumes or dedicated streams.
    4. Health Checks and Auto-Recovery: Implement health endpoints in the worker containers and a recovery policy in the manager to automatically restart failed workers.
    5. Capability Discovery: Implement a mechanism where the RemoteAdapter queries the worker for supported methods, allowing the system (e.g., a node editor) to reflect available capabilities dynamically.

  9. MRC System Architecture Overview

    The MRC system is designed to abstract the differences between six different collaborative robot vendors (A-F) whose SDKs vary in function signatures and communication protocols (C++ bindings, RPC, TCP, REST). The architecture uses a FastAPI-based unified routing controller and a Core ABC (Abstract Base Class) adapter pattern to provide a consistent API and a React Flow-based node editor for sequence orchestration.

  10. Manage robot drawing sessions with a background lifecycle

    To handle long-running drawing tasks (1-5 minutes) without blocking HTTP requests, the system uses a DrawingSession managed by a session_manager. Each session runs in its own independent daemon thread to maintain compatibility with synchronous socket and sleep operations.

    The session follows a 6-state machine, with all transitions protected by a threading.Lock:

    • pending: Created, awaiting start.
    • running: Thread started and initialization sequence executing.
    • stopping: Cancel request received.
    • completed: Normal termination and return to home position.
    • stopped: Terminated via user cancellation.
    • failed: Terminated due to exceptions or connection loss.

  11. Implement site monitoring using Tailscale and Hybrid Push-Pull model

    To monitor remote site servers that are not directly accessible from the outside, use Tailscale to create a mesh network. The monitoring architecture employs a hybrid approach:

    1. Pull Model (On-demand): A central monitoring service calls the /api/v1/system/health-detail endpoint on site servers to collect current status.
    2. Push Model (Heartbeat): Site servers use a heartbeat reporter to periodically push data. To prevent data loss during network outages, data is buffered in a deque(maxlen=1000) and transmitted in bulk once connectivity is restored.

    Current Limitation: Metrics are currently stored as JSON blobs, which limits time-series analysis and alerting capabilities. Future iterations should migrate to Prometheus or OpenTelemetry.

  12. Azure AI-500 Expert Certification Requirements

    The AI-500 (Multi-Agent AI Solutions Expert) certification is an advanced track focusing on multi-agent architecture design, Azure implementation, evaluation, optimization, monitoring, security, governance, and deployment.

    Prerequisite: You must obtain the AI-103 certification before you can earn the AI-500 Expert designation.

    Note: As of the roadmap date, AI-500 is in beta, is available in English only, and may have delayed result notifications.