DEV Community: K Hari

Designing Scalable RESTful APIs for Dairy Farm Intelligence: FarmersMilk API Architecture

K Hari — Tue, 01 Apr 2025 19:43:55 +0000

Introduction: The Heart of FarmersMilk

Imagine running a dairy farm where everything—from tracking each buffalo’s milk production to delivering fresh milk to customers—works together seamlessly through a digital system. That’s the dream behind FarmersMilk, a platform I’m building as its sole developer and architect. At the core of this system are APIs (Application Programming Interfaces), built using .NET Core 8.0, that act like the glue connecting all the pieces: the animals, the farmers, the delivery drivers, the customers, and even smart AI agents.
These APIs are the digital heartbeat of FarmersMilk. They let farmers register new buffaloes, log daily milk yields, verify deliveries with QR codes, and even trigger AI to figure out the fastest delivery routes. Whether it’s a farmer checking stats on a mobile app or a customer confirming their milk drop-off, every action flows through these APIs. They’re not just code—they’re what makes this smart dairy farm tick.

API Architecture Overview: A Solid Foundation

To make FarmersMilk reliable and easy to grow, I’ve built the API with .NET Core 8.0 using a layered structure. Think of it like a well-organized farmhouse with different floors, each handling a specific job:

   •**Controllers:** These are the front doors. They welcome requests 
      (like “Hey, record this milk yield”) from apps or websites and 
       send them to the right place.
   •**Services:** This is where the real work happens. Services handle 
      the farm’s rules—like making sure milk amounts make sense—before 
      anything gets saved.
   •**Repositories:** These are the record keepers, talking to the 
      database (using Entity Framework Core) to store or fetch data, 
       like a Buffalo’s health history.

This setup keeps things tidy. If I need to tweak how data is stored, I can adjust the repositories without messing up the services or controllers. It’s like fixing the basement without disturbing the kitchen.
I’ve also stuck to REST principles, which are like a universal language for APIs:
•GET: To grab info, like a buffalo’s details.
•POST: To add new stuff, like a milk record.
•PUT: To update things, like a delivery status.
•DELETE: To remove outdated entries, like a retired buffalo.

Here’s a diagram to picture it:

And here’s how the layers fit together:

Key API Endpoints: The Everyday Tools
Here are some of the main APIs that keep FarmersMilk running smoothly, with examples of what they do:

1.Buffalo Registration (POST /api/buffalo)
This is how a new buffalo joins the farm. Farmers send details like breed and RFID tag, and the system saves them.

Example Request:

JSON

POST /api/buffalo
{
    "breed": "Murrah",
    "rfidTag": "123456789",
    "healthStatus": "Healthy"
}

2.Milk Record (POST /api/milk/record)
Every milking session gets logged here—how much milk, which buffalo, and when. It’s key for tracking productivity.
Example Request:

JSON

POST /api/milk/record
{
    "animalId": 1,
    "liters": 5.5,
    "timestamp": "2023-10-01T08:00:00Z"
}

3.QR Code Verification (POST /api/qr/scan)
When milk reaches a customer, they scan a QR code. This API confirms the delivery and logs it.

Example Request:

JSON

POST /api/qr/scan
{
    "deliveryId": 1001,
    "qrCode": "ABC123",
    "scanTime": "2023-10-01T09:30:00Z",
    "location": {"lat": 12.34, "lon": 56.78}
}

4.Delivery Status Update (PUT /api/delivery/update)
Drivers update this as they go—think “In Transit” or “Delivered”—so everyone knows what’s happening.

Example Request:

JSON

PUT /api/delivery/update
{
    "deliveryId": 1001,
    "status": "Delivered"
}

5.AI Route Optimization Trigger (GET /api/route/optimize)
This kicks off the AI to find the best delivery routes based on orders and GPS data.
Example Request:
JSON

GET /api/route/optimize

These endpoints are the workhorses of the platform, making sure every task gets done efficiently.

Security Measures: Keeping It Safe
Farm data and customer info need to stay secure, so I’ve locked down the API with JSON Web Tokens (JWT). Here’s how it works:
•Login: Users (farmers, drivers, admins) log in, and if their
credentials check out, they get a JWT token—a digital ID card.
•Token Check: Every API request includes this token. Middleware
(a gatekeeper) verifies it before letting the request through.
•Roles: The token says who you are—like “Admin” or “Driver”—and
what you can do. Only admins can delete buffaloes, while drivers
can update deliveries.

Here’s a code snippet showing how it’s enforced:

C# Code

[Authorize(Roles = "Admin")]
[HttpDelete("/api/buffalo/{id}")]
public IActionResult DeleteBuffalo(int id)
{
    _buffaloService.DeleteBuffalo(id);
    return Ok("Buffalo deleted");
}

Only admins get past that [Authorize] line. It’s like a “Staff Only” sign for the API.

Sample Code Snippets: A Peek Under the Hood
Let’s look at some code to see how this all comes together.

Milk Controller Example
This handles milk-related requests:

C# Code

[ApiController]
[Route("api/milk")]
public class MilkController : ControllerBase
{
    private readonly IMilkService _milkService;

    public MilkController(IMilkService milkService)
    {
        _milkService = milkService;
    }

    [HttpPost("record")]
    public IActionResult AddMilkRecord([FromBody] MilkInputModel input)
    {
        if (input.Liters <= 0 || input.AnimalId == 0)
        {
            return BadRequest("Invalid data: Liters must be positive and AnimalId required.");
        }

        _milkService.AddMilkRecord(input);
        return Ok("Milk record saved!");
    }

    [HttpGet("yield/{animalId}")]
    public IActionResult GetMilkYield(int animalId)
    {
        var yield = _milkService.GetMilkYield(animalId);
        return Ok(yield);
    }
}

The controller uses MilkService (injected via dependency injection) to do the heavy lifting.

Milk Service Example
Here’s how the service processes that data:

C# Code

public class MilkService : IMilkService
{
    private readonly ApplicationDbContext _context;

    public MilkService(ApplicationDbContext context)
    {
        _context = context;
    }

    public void AddMilkRecord(MilkInputModel input)
    {
        var record = new MilkRecord
        {
            AnimalId = input.AnimalId,
            Liters = input.Liters,
            Timestamp = input.Timestamp ?? DateTime.UtcNow
        };
        _context.MilkRecords.Add(record);
        _context.SaveChanges();
    }

    public decimal GetMilkYield(int animalId)
    {
        return _context.MilkRecords
            .Where(m => m.AnimalId == animalId)
            .Sum(m => m.Liters);
    }
}

And in Program.cs, I tell the system to provide MilkService when needed:

builder.Services.AddScoped<IMilkService, MilkService>();

This keeps the code clean and reusable.

Real-Time Communication: Teaming Up with AI
The APIs don’t work alone—they team up with AI agents I built in Python using FastAPI. For example:

•**Health Alerts**: If the AI spots trouble (like a buffalo producing less milk), it sends:

JSON CODE

POST /api/health/alert
{
    "animalId": 1,
    "alertType": "LowMilkYield",
    "description": "Milk yield dropped 30% in 3 days."
}

•Route Updates: After optimizing routes, the AI updates the system:

JSON CODE

PUT /api/route/update
{
    "driverId": 5,
    "route": [
        {"customerId": 101, "address": "123 Farm Lane"},
        {"customerId": 102, "address": "456 Country Rd"}
    ]
}

In the future, I’ll add Webhooks and SignalR for instant updates—like live delivery tracking.

Testing & Scalability: Ready for Growth
To keep the API solid and scalable:
•Testing: I use xUnit for unit tests (checking each piece works) and
Postman to test the full API flow. Example test:
C# Code

[Fact]
public void AddMilkRecord_ShouldSave()
{
    var context = new ApplicationDbContext(new DbContextOptionsBuilder().UseInMemoryDatabase("TestDb").Options);
    var service = new MilkService(context);
    var input = new MilkInputModel { AnimalId = 1, Liters = 5.0 };
    service.AddMilkRecord(input);
    Assert.Equal(5.0, context.MilkRecords.First().Liters);
}

Scalability: Async database calls, lightweight DTOs, and Azure App Services with auto-scaling handle up to 10,000 requests daily without breaking a sweat.

Conclusion: The Digital Dairy Future
The FarmersMilk API isn’t just tech—it’s the backbone of a smarter dairy farm. It ties everything together, from milk records to delivery routes, making the farm more efficient and profitable. As I add more features—like better AI or slicker apps—this API will keep it all connected and growing smoothly.

Building an Intelligent AI System for Dairy Farm Management: The FarmersMilk Story

K Hari — Sat, 29 Mar 2025 21:06:00 +0000

The AI systems I developed for FarmersMilk, a dairy tech platform combining .NET, Blazor, Python, FastAPI, and AI agents to transform traditional farm operations. This real-world implementation demonstrates my ability to design scalable, intelligent systems for rural agritech. As the sole architect and developer, I conceptualized and implemented every component of this system, from hardware integration to AI agent design.

When I began developing FarmersMilk, I had a straightforward goal: to digitize operations for our family dairy farm in India. I soon realized this project required more than basic digital tools—it needed intelligent systems that could analyze, predict, and take action, similar to how an experienced farm manager would.
This journey from a simple digital system to a network of AI agents taught me valuable lessons about practical AI implementation. Today, I'll share how we transformed traditional dairy farming operations using accessible technology and thoughtful architecture design.

Moving Beyond Traditional Systems

Conventional dairy management software typically offers static functionality—data input and reporting. However, farming is dynamic, with daily changes in delivery routes, milk production, and animal health. I needed a more responsive solution.

The gap between traditional systems and our needs:

Traditional Systems Our Requirements

Periodic reports Real-time insights
Manual decision-making Automated actions
Fixed workflows Adaptive processes
Data collection focus Action-oriented intelligence

My approach was to create AI agents that work continuously to make decisions in the background—transforming passive data collection into active farm management.

Team-Based Architecture

I developed a hierarchical structure inspired by enterprise systems:
• A Super-Agent coordinates overall operations
• Specialized Sub-agents handle specific functions:
o Route optimization
o Animal health monitoring
o Government milk price alerts
o Weather prediction (in development)
Each agent monitors, processes, and acts on real-time farm data.

"FarmersMilk AI Agent Architecture : Hierarchical AI agent architecture showing the Super-Agent coordinating specialized sub-agents for route optimization, health monitoring, and price alerts"

This architectural design follows a key principle: each agent should excel at a specific task rather than building one complex system trying to do everything. The modularity allows us to add new agents or modify existing ones without disrupting the entire system.

Route Optimization Agent

Delivering milk to over 50 homes daily in rural areas presented logistical challenges.

I developed this agent using Python and Google OR-Tools to calculate the most efficient delivery routes based on GPS locations, time requirements, and fuel costs:

Python Code

from ortools.constraint_solver import routing_enums_pb2
from ortools.constraint_solver import pywrapcp

def optimize_route(locations):
    # Define the routing index manager
    manager = pywrapcp.RoutingIndexManager(len(locations), 1, 0)
    routing = pywrapcp.RoutingModel(manager)

    # Cost function goes here...

    solution = routing.SolveWithParameters(search_parameters)
    return extract_routes(solution)

This implementation resulted in a 20% reduction in fuel consumption and improved on-time delivery performance, even to remote locations.

Health Monitoring Agent

Buffalo health issues aren't always immediately apparent. However, their milk production, feeding patterns, and movement data (tracked via RFID) provide valuable indicators.
I trained a machine learning model with TensorFlow to identify potential health concerns before visible symptoms appear:

Python Code

def monitor_buffalo(milk_data, feeding_pattern):
    model = tf.keras.models.load_model('buffalo_health_model.h5')
    result = model.predict([milk_data, feeding_pattern])
    if result == 'Risk':
        alert_vet()

This proactive approach allows us to address health issues earlier, reducing treatment expenses and minimizing production losses.

Milk Price Alert Agent

Government regulations in India cause frequent changes in milk prices.
This agent automatically checks the official government website each morning for price updates:

Python Code

def check_price_update():
    latest_price = scrape_government_portal()
    if latest_price != cached_price:
        notify_admins()
        update_price_in_system(latest_price)

When changes occur, it sends notifications to administrators, distributors, and customers through our application.

Technical Integration
All AI agents operate as FastAPI microservices written in Python.
Our customer portal and delivery dashboards, built with Blazor, communicate with these services via HTTP requests, creating a seamless connection between our .NET Core backend and Python-based AI components:

C# Code

[HttpGet("api/route/optimize")]
public async Task<IActionResult> OptimizeRoute()
{
    var response = await _httpClient.GetAsync("http://ai-agent-api/route");
    var route = await response.Content.ReadFromJsonAsync<RouteResult>();
    return Ok(route);
}

This integration bridges .NET Core, Python, and AI into one cohesive system.

"FarmersMilk System Data Flow: Data flowing from input sources (RFID, GPS, government websites) through AI processing to user interfaces, with database connections indicated."

System Architecture
As the sole architect and developer of FarmersMilk, I designed and implemented every component of the system—from frontend dashboards and backend services to AI microservices and integrations with RFID hardware and IoT sensors. This comprehensive approach allowed me to ensure seamless operation across all layers.

"FarmersMilk Technical Architecture: This layered system architecture with User Interface Layer at the top, followed by Frontend Layer, Backend Layer, AI Agent Layer, and Data Source Layer at the bottom. This technical architecture shows the five-layer approach from user interfaces to data sources"

The complete architecture follows a layered approach:

1.User Interface Layer: Blazor-based responsive interfaces for
customers, administrators, and delivery personnel.

2.Frontend Layer: Component-based design with efficient state
management and API integrations.

3.Backend Layer: .NET Core APIs handling authentication, business
logic, and database operations.

4.AI Agent Layer: Python-based intelligent agents deployed as FastAPI
microservices.

5.Data Source Layer: Physical hardware (RFID, GPS, IoT) and external
data sources (government portals).

This architecture enables both vertical scaling (adding more resources to existing components) and horizontal scaling (adding new agents or capabilities) as the system grows.

Future Developments
I'm currently working on additional agents to further enhance our farm operations:

  •   **Climate-based Yield Predictor:** Using temperature and humidity 
      data to forecast production levels, this agent will help us plan 
      inventory and staffing needs 7-14 days in advance.

  •   **Customer Satisfaction Analyzer:** By processing delivery feedback 
      and scanning patterns, this agent will identify potential service 
      issues before they lead to customer churn.

   •**Animal Stress Detector:** Leveraging IoT sensors that monitor 
      buffalo movement patterns and ambient conditions, this agent will 
      detect early signs of stress that could affect animal welfare and 
      production.

What makes these new agents exciting is how they'll interact with our existing system, creating a more comprehensive intelligence network that addresses both operational and strategic needs.

Real-World Impact
The implementation of our AI agent system has delivered tangible benefits:

  •**Cost Reduction:** 20% decrease in fuel costs and 15% reduction in 
     veterinary expenses
  •   **Time Savings:** Delivery planning reduced from 1 hour to 5 
     minutes daily
  •   **Quality Improvement:** Early health intervention has improved 
     milk quality metrics
  •   **Customer Satisfaction:** On-time delivery rate increased from 78% 
      to 96%

"FarmersMilk Performance Metrics: Performance improvements after AI implementation showing significant reductions in costs and time with increased delivery reliability"

What makes these improvements significant is that they were achieved without expensive enterprise software or complex infrastructure—just smart application of accessible tools and focused AI solutions.

Conclusion
Effective AI solutions don't require massive scale or complex infrastructure. Even small operations like our farm can benefit from targeted, efficient agents that address specific challenges.

The key lessons from building FarmersMilk:
1.Start small and focused: Build agents that solve one problem
extremely well.

2.Use available tools: Combine existing technologies rather than
building everything from scratch.

3.Measure real impact: Focus on metrics that directly affect your
operations.

4.Design for growth: Create modular systems that can evolve with your
needs.

With FarmersMilk, I'm creating technology that goes beyond data collection to take meaningful action in farm management—proving that with the right approach, AI can transform even traditional industries like agriculture.

Related Articles
•How I Built an AI-Powered Milk Delivery System – Hashnode
•Blazor + AI: My Dairy Farm Platform – Medium
•Route Optimization with Python and .NET – Dev.to

This article is also published on Medium, Dev.to, and Hashnode.

Creating a Super-Agent to Manage Milk, Routes, Health & Humans

K Hari — Fri, 28 Mar 2025 20:38:01 +0000

How a Small Family Farm Inspired Me to Build Something Bigger with Code (and AI)
From RFID tags to intelligent agents—how a small dairy project turned into a full-stack tech venture

I’ve never personally visited a dairy farm in India, even though my family owns one. Growing up, it was just something happening far away—part of our background, our roots, but not something I imagined I'd be involved in.
That changed when we started talking seriously about expansion.
What started as a casual thought—"let’s grow the farm"—quickly became a mission to modernize it. And not just expand in size, but in intelligence. I realized I could bring in what I know best: software, AI, and systems architecture.

From Manual to Smart: Where It All Began
I started simple—with RFID ear tags.
The idea was to scan a buffalo and instantly see its milk production, health history, and breeding data. I built the backend with .NET Core, the frontend with Blazor, and structured everything in SQL Server.
That alone brought the farm out of notebooks and into dashboards.
But it didn’t stop there.

Introducing AI into a Rural Ecosystem
Once the base system worked, the next question was obvious:
“What if this system could think, predict, and assist?”
So, I began integrating AI modules into FarmersMilk—not as gimmicks but as actual agents solving real problems.

AI Route Optimization Agent
FarmersMilk deliveries are done manually now,
but as we scale milk distribution to nearby cities, I’ve built an AI-based Route Optimization Agent.
It factors in:
• Delivery locations
• Road conditions
• Fuel consumption
• Real-time data from GPS trackers
And then it calculates the fastest, most fuel-efficient route for our drivers using AI-powered algorithms.
It’s like Google Maps but tuned for rural delivery realities, not highways.

Conversational AI Agent (Farmer Assistant)
Many of our workers and delivery staff don’t interact well with dashboards or UIs. So, I’m building a Conversational AI Agent that can respond to voice/text queries in Telugu, Hindi, and English.
A farmer can simply say:
“How much milk did A5 produce last week?”
And the system replies with the exact record.
This makes technology accessible to non-technical users and adds a human-like interface on top of our backend.

AI Health Monitoring & Predictive Maintenance
We're also training models to analyze:
• Milk production drops
• RFID scan frequency
• Feeding patterns
• Temperature/vibration data (from IoT sensors)
The goal is to predict early health issues or machine failures before they become visible or cause damage.
These agents will send alerts to farm staff and recommend actions—just like a virtual vet or technician.

How It All Comes Together
I’ve designed a hierarchical AI agent system where:
• A Super-Agent manages multiple specialized agents
• Each agent handles a unique role: route planning, animal health, delivery tracking, customer support
• Data flows between agents and the .NET Core backend to create a real-time, decision-making ecosystem
It’s not just software anymore, it’s a thinking farm system.

Final Thought
This didn’t come from a lab or a funding pitch deck.
It came from a quiet farm that deserved better tools.
I’m still not a farmer. But now, I’m building tech that listens like one, plans like one, and supports the people who live that life daily.
If you think farms can’t be smart, you haven’t seen what happens when AI meets tradition.