DEV Community: es404020

Building a Custom Screen Time Flutter App with iOS Native APIs

es404020 — Mon, 02 Mar 2026 06:30:09 +0000

Integrating Apple's powerful Screen Time APIs—Family Controls, Managed Settings, and Device Activity—into a cross-platform Flutter application requires bridging native iOS capabilities with Dart code. Below is a comprehensive guide on how this architecture works, complete with code implementations.

Core Architecture: The Flutter-to-iOS Bridge

Because the Family Control APIs are exclusively available on iOS 15/16+, there isn't a single Flutter plugin that natively handles everything. The most reliable approach is to build a custom MethodChannel bridging Flutter to Swift.

Step 1: The Flutter Service (`screen_time_bridge.dart`)

On the Dart side, we define a class to communicate with iOS. It handles requesting authorization, showing the app picker, and adjusting earned time balances.

import 'package:flutter/services.dart';

class ScreenTimeBridge {
  static const _channel = MethodChannel('com.yourcompany.app/screen_time');

  Future<bool> requestAuthorization() async {
    try {
      final result = await _channel.invokeMethod<bool>('requestAuthorization');
      return result ?? false;
    } catch (e) {
      print('Authorization failed: $e');
      return false;
    }
  }

  Future<List<String>?> showAppPicker() async {
    try {
      final result = await _channel.invokeMethod<List<dynamic>>('showAppPicker');
      return result?.cast<String>();
    } catch (e) {
      print('Failed to open app picker: $e');
      return null;
    }
  }

  Future<bool> updateBalance(int minutes) async {
    try {
      final result = await _channel.invokeMethod<bool>('updateBalance', {
        'minutes': minutes,
      });
      return result ?? false;
    } catch (e) {
      print('Failed to update balance: $e');
      return false;
    }
  }
}

Step 2: The Native Swift Implementation

In iOS, your FlutterPlugin implementation requires importing specific Screen Time frameworks. Crucially, your app and its extensions must share an App Group to communicate synchronously.

import Flutter
import FamilyControls
import ManagedSettings
import DeviceActivity
import SwiftUI

@available(iOS 16.0, *)
class ScreenTimeBridge: NSObject, FlutterPlugin {
    private let center = AuthorizationCenter.shared
    private let store = ManagedSettingsStore()
    private let activityCenter = DeviceActivityCenter()

    // Shared App Group defaults to communicate with Background Extensions
    private let sharedDefaults = UserDefaults(suiteName: "group.com.yourcompany.app.shared")

    static func register(with registrar: FlutterPluginRegistrar) {
        let channel = FlutterMethodChannel(name: "com.yourcompany.app/screen_time", binaryMessenger: registrar.messenger())
        let instance = ScreenTimeBridge()
        registrar.addMethodCallDelegate(instance, channel: channel)
    }

    func handle(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
        switch call.method {
        case "requestAuthorization":
            Task {
                do {
                    // .individual means authorizing for the current user's device autonomously
                    try await center.requestAuthorization(for: .individual)
                    result(true)
                } catch {
                    result(FlutterError(code: "AUTH_FAILED", message: error.localizedDescription, details: nil))
                }
            }
        // ... Handle other cases (showAppPicker, updateBalance, etc.) ...
        default:
            result(FlutterMethodNotImplemented)
        }
    }
}

Handling the App Picker using SwiftUI

Flutter cannot natively render iOS's FamilyActivityPicker. Instead, we wrap it inside a UIHostingController and present it natively over the active Flutter view controller.

// Triggered via Flutter "showAppPicker" method
func presentAppPicker(result: @escaping FlutterResult) {
    let picker = ActivityPickerView { selection in
        // Save highly secure selection tokens to App Group UserDefaults
        if let data = try? JSONEncoder().encode(selection) {
            sharedDefaults?.set(data, forKey: "familyActivitySelection")
            sharedDefaults?.synchronize()
        }

        // Return placeholder tokens back to Flutter if needed
        let dummyTokens = (0..<selection.applicationTokens.count).map { "token_\($0)" }
        result(dummyTokens)
    }

    let hostingController = UIHostingController(rootView: picker)

    // Present over the main Flutter UI
    if let rootVC = UIApplication.shared.keyWindow?.rootViewController {
        rootVC.present(hostingController, animated: true)
    }
}

// SwiftUI Picker Wrapper
@available(iOS 16.0, *)
struct ActivityPickerView: View {
    @State private var selection = FamilyActivitySelection()
    @Environment(\.dismiss) var dismiss
    var onComplete: (FamilyActivitySelection) -> Void

    var body: some View {
        NavigationView {
            FamilyActivityPicker(selection: $selection)
                .toolbar {
                    ToolbarItem(placement: .confirmationAction) {
                        Button("Done") {
                            onComplete(selection)
                            dismiss()
                        }
                    }
                }
        }
    }
}

Applying Shields & Blocking Apps

Once apps are selected, you block them by extracting the tokens from UserDefaults and dropping them directly into the ManagedSettingsStore.

func applyShields() {
    guard let data = sharedDefaults?.data(forKey: "familyActivitySelection"),
          let selection = try? JSONDecoder().decode(FamilyActivitySelection.self, from: data) else {
        return
    }

    // Block selected apps natively immediately
    store.shield.applications = selection.applicationTokens
    store.shield.applicationCategories = .specific(selection.categoryTokens)
    store.shield.webDomains = selection.webDomainTokens

    sharedDefaults?.set(true, forKey: "shieldsEnabled")
    sharedDefaults?.synchronize()
}

Monitoring Usage Limits and The 15-Minute Rule

Apple securely handles background app usage monitoring through DeviceActivityCenter. However, there is a critical constraint: DeviceActivity limits must be a minimum of 15 minutes long.

If your platform requires precise timers shorter than 15 minutes, you must construct a fallback system using background Timer instances, manual polling, and local UNUserNotification alerts to manually trigger the applyShield logic precisely when time expires.

Otherwise, utilizing native system scheduling looks like this:

func startMonitoring(minutes: Int) {
    // Note: 'minutes' must be >= 15 for accurate OS scheduling 
    let now = Date()
    let endDate = now.addingTimeInterval(TimeInterval(minutes * 60)) 

    let schedule = DeviceActivitySchedule(
        intervalStart: Calendar.current.dateComponents([.hour, .minute, .second], from: now),
        intervalEnd: Calendar.current.dateComponents([.hour, .minute, .second], from: endDate),
        repeats: false
    )

    do {
        // Starts background tracking for this time bracket
        try activityCenter.startMonitoring(DeviceActivityName("daily"), during: schedule)
    } catch {
        print("Failed to monitor: \(error)")
    }
}

When the tracked time hits its threshold, Apple fires a DeviceActivityMonitorExtension. Since the extension operates in an isolated background sandbox, passing data via the shared App Group UserDefaults guarantees synchronization between Flutter and iOS contexts.

🛑 Critical Production Constraint: Required Entitlements

If you construct this architecture and build it onto your local iPhone via Xcode, it will work perfectly on a Development provisioning profile.

However, it will flatly fail and be rejected in production (TestFlight and the App Store) unless you obtain explicit App Store permission.

To distribute applications leveraging FamilyControls and Screen Time, developers must submit a formal request to Apple for the Family Controls Distribution Entitlement. During the review, Apple meticulously inspects whether your use case cleanly aligns with productivity workflows or parental control utilities.

Without this entitlement explicitly granted on your developer account and assigned to your App Profile, your screen time blockers are fundamentally limited to Debug mode on developer-local devices.

A Gentle, Fun, and Professional Guide to Q‑Learning and Epsilon‑Greedy

es404020 — Mon, 08 Dec 2025 09:07:32 +0000

Welcome to this friendly walkthrough of one of the most important ideas in modern artificial intelligence:

Q‑Learning, the algorithm that teaches computers how to make decisions by trying things out, getting rewarded, and gradually learning what works best.

This article is designed for non‑technical readers, yet written with the polish of a technical writer. Expect clarity, a bit of geeky charm, and even some fun illustrations!

🧠 What Is Q‑Learning?

Q‑Learning is a Reinforcement Learning (RL) algorithm. That simply means:

An agent (computer program)
Lives in an environment
Takes actions
Gets rewards or punishments
And tries to maximize good outcomes

Think of it as teaching a child to behave using snacks and timeouts. Except the child is a robot. And the snacks are numbers.

📘 The Famous Q‑Learning Formula

Here is the magical update equation:

Q[state, action] = Q[state, action] 
    + α * (reward + γ * best_next 
    - Q[state, action])

What does it mean in normal-human English?

Q[state, action] = “How good is it to take this action in this situation?”
α (alpha) = “How fast should I learn?”
γ (gamma) = “How much should I care about the future?”
best_next = “What’s the best move I can make next?”

Or even simpler:

New value = Old value + Learning Rate × (Surprise)

Robots learn from surprises… just like toddlers.

🎲 What Is Epsilon‑Greedy?

Epsilon‑Greedy is a simple but genius strategy for making decisions while learning.

It means:

Most of the time → pick the best-known choice
Sometimes (epsilon % of the time) → try something random

This prevents the robot from becoming a stubborn old man who refuses to try new things.

Example (with cartoons!)

         +-------------------------------+
         |  Robot Brain:                 |
         |  "Should I try a new button?" |
         +-------------------------------+
                |            |
         90% -->| Pick best  |
         10% -->| Try random |

📜 Short History of Q‑Learning (Fun Version)

📅 1950s — The Ancestors

Mathematician Richard Bellman invents the Bellman Equation

…without realizing he’s basically inventing robot parenting.

📅 1989 — Chris Watkins Creates Q‑Learning

Chris Watkins invents Q‑Learning and proves it works.

This is the “Eureka!” moment that let computers learn by trial‑and‑error.

📅 2015 — DeepMind Makes It Cool

DeepMind combines Q‑Learning with Neural Networks → Deep Q‑Networks (DQN)

It becomes so good that it beats humans at Atari games.

Humans pretend they’re “not impressed,” but we all were.

📅 Today

Q‑Learning runs in:

Robotics
Gaming AI
Smart traffic lights
Finance
Logistics
Self‑driving systems

It's everywhere… silently learning everything.

🤖 Why People Love Q‑Learning

It’s simple
It’s powerful
It works without knowing how the world works (model‑free)
It’s the foundation of many modern AI breakthroughs

It’s like duct tape for machine learning: simple, reliable, and surprisingly strong.

🎨 Simple Visual Concept Diagram

Below is a small ASCII illustration to help visualize the idea:

+-----------+       +-----------+       +-----------+
|  State    | --→   |  Action   | --→   |  Reward   |
+-----------+       +-----------+       +-----------+
       ↑                   ↓                  |
       |              Q-Value Update  ←-------+
       +--------------------------------------+

And that loop repeats until the agent becomes a genius.

📂 Summary

Q‑Learning teaches a machine to make smart decisions through experience.

Epsilon-Greedy helps the machine explore new possibilities while still using what it has learned.

Together, they allow robots, programs, and intelligent systems to learn like humans—just with fewer snack breaks.

🎉 Final Thoughts

If you understand this article, congratulations:

You now know more about Q‑Learning than most people who casually talk about AI.

And you did it without needing a PhD or a room full of whiteboards.

Bracket Matching / Valid Parentheses

es404020 — Mon, 23 Jun 2025 11:03:17 +0000

Bracket matching is a common problem in programming interviews and coding challenges. The goal is to determine whether a given string made up of brackets is balanced and properly nested.

Typical brackets to validate include:

Parentheses: ()
Square brackets: []
Curly braces: {}

Problem Statement

Given a string containing only the characters (, ), {, }, [ and ], write a function to determine if the input string is valid.

A string is considered valid if:

Open brackets are closed by the same type of brackets.
Open brackets are closed in the correct order.
Every closing bracket has a corresponding opening bracket of the same type.

Original JavaScript Implementation

const bracket = (value) => {
  let array = value.split(""); // Convert input string into an array of characters
  let stack = [];               // Stack to hold opening brackets
  let stack_close = [];         // Stack to hold unmatched closing brackets (not necessary)
  let i = 0;

  // If the total number of brackets is odd, it's automatically invalid
  if (array.length % 2 != 0) {
    return false;
  }

  // Loop through each character
  while (array.length > i) {
    if (array[i].includes('(') || array[i].includes('[') || array[i].includes('{')) {
      stack.push(array[i]); // Push opening bracket to the stack
    } else {
      stack_close.push(array[i]); // Push closing bracket to the close stack

      console.log(stack[stack.length - 1], array[i]); // Debug log

      // Check for matching bracket pairs
      if (array[i].includes(']') && stack[stack.length - 1] == '[') {
        stack.pop();
        stack_close.pop();
      } else if (array[i].includes(')') && stack[stack.length - 1] == '(') {
        stack.pop();
        stack_close.pop();
      } else if (array[i].includes('}') && stack[stack.length - 1] == '{') {
        stack.pop();
        stack_close.pop();
      }
    }
    i++;
  }

  // If both stacks are empty, the brackets are properly matched
  if (stack.length == 0 && stack_close.length == 0) {
    return true;
  } else {
    return false;
  }
}

Explanation Line-by-Line

const bracket = (value) => {

Defines a function named bracket that takes a string input value.

let array = value.split("");

Splits the string into an array of characters to process them individually.

let stack = [];
let stack_close = [];

Two stacks are initialized: one for opening brackets and one for closing brackets. Only stack is actually necessary.

let i = 0;

Index i initialized to loop through the array.

if (array.length % 2 != 0) {
  return false;
}

If the length of the array is odd, it can’t be balanced, so return false early.

while (array.length > i) {

Starts a while loop to iterate through the array.

  if (array[i].includes('(') || array[i].includes('[') || array[i].includes('{')) {
    stack.push(array[i]);
  }

Checks if the current character is an opening bracket and pushes it onto the stack.

  else {
    stack_close.push(array[i]);

If it’s a closing bracket, push it to the close stack (this step is not needed for logic).

    console.log(stack[stack.length - 1], array[i]);

Debug print of the last opened bracket and the current closing bracket.

    if (array[i].includes(']') && stack[stack.length - 1] == '[') {
      stack.pop();
      stack_close.pop();
    } else if (array[i].includes(')') && stack[stack.length - 1] == '(') {
      stack.pop();
      stack_close.pop();
    } else if (array[i].includes('}') && stack[stack.length - 1] == '{') {
      stack.pop();
      stack_close.pop();
    }
  }

Checks if the current closing bracket matches the last opening bracket. If yes, both are removed from their stacks.

  i++;
}

Increment index and continue loop.

if (stack.length == 0 && stack_close.length == 0) {
  return true;
} else {
  return false;
}

At the end, if both stacks are empty, the brackets were all properly matched and nested.

Example Usages

bracket("{[()]}"); // true
bracket("([)]");   // false
bracket("([]{})"); // true
bracket("((" );    // false

Time and Space Complexity

Time Complexity: O(n), where n is the length of the string.
Space Complexity: O(n), because of the stack usage.

Conclusion

This custom bracket validation implementation uses two stacks and performs step-by-step matching of brackets. While effective, it can be simplified by using only one stack for better efficiency and readability.

[Boost]

es404020 — Mon, 07 Apr 2025 19:25:14 +0000

es404020

Apr 3 '25

Building a Weather-Savvy AI Agent Using LangGraph, LangChain, and OpenAI

#langchain #langgraph #openai #python

Comments

3 min read

Building a Weather-Savvy AI Agent Using LangGraph, LangChain, and OpenAI

es404020 — Thu, 03 Apr 2025 11:03:45 +0000

Have you ever wanted to build an AI assistant that can actually respond to questions about the weather using real-time data? In this blog post, I’ll show you how to build a smart agent that integrates LangGraph, LangChain, OpenAI, and a weather API to deliver real-time temperature updates.

We’ll build a conversational agent that:

✅ Understands your messages with GPT-4

✅ Detects when to use tools (like checking the weather)

✅ Returns the current temperature for any given location

Let’s dive in. 🌍🌦️

📦 Requirements

Before we begin, make sure you have the following Python packages installed:

pip install python-weather openai langchain langgraph python-dotenv

Also, grab your OpenAI API key and pop it into a .env file like so:

OPENAI_API_KEY=your-api-key-here

🧠 The Code

Step 1: Set Up Environment & Imports

We start by importing all the necessary libraries and loading our environment variables.

from dotenv import load_dotenv
from openai import OpenAI
import python_weather
import asyncio

from langgraph.graph import END, START, StateGraph, MessagesState
from langchain_openai import ChatOpenAI
from langchain_core.tools import tool
from langgraph.prebuilt import ToolNode
from typing import Literal

load_dotenv()

Step 2: Create a Weather Tool 🌡️

We use python_weather to fetch the current temperature asynchronously.

async def generate_response(location):
    async with python_weather.Client(unit=python_weather.IMPERIAL) as client:
        weather = await client.get(location)
        return weather.temperature

@tool
def get_weather(location: str):
    """Call to get the current temperature."""
    return asyncio.run(generate_response(location))

This tool will later be integrated with our AI agent.

Step 3: Connect Tools to the Model

Next, we bind the get_weather tool to GPT-4 using LangChain’s ChatOpenAI.

tools = [get_weather]
model = ChatOpenAI(model="gpt-4o-mini").bind_tools(tools)

Step 4: Create the Agent Workflow using LangGraph

Here's where the magic happens! We define how the agent will think and act using a graph-based workflow.

def call_model(state: MessagesState):
    messages = state["messages"]
    response = model.invoke(messages)
    return {"messages": [response]}

def should_continue(state: MessagesState) -> Literal["tools", END]:
    messages = state["messages"]
    last_message = messages[-1]
    if last_message.tool_calls:
        return "tools"
    return END

workflow = StateGraph(MessagesState)
tool_node = ToolNode(tools)

workflow.add_node("agent", call_model)
workflow.add_node("tools", tool_node)

workflow.add_edge(START, "agent")
workflow.add_conditional_edges("agent", should_continue)
workflow.add_edge("tools", "agent")

graph = workflow.compile()

This setup allows the agent to:

Respond to user input
Decide if it needs a tool
Call the weather tool if needed
Respond again with the result

Step 5: Visualize the Workflow 🌐

If you're using Jupyter, visualize your agent's graph with Mermaid:

from IPython.display import Image, display
from langchain_core.runnables.graph import MermaidDrawMethod

display(
    Image(
        graph.get_graph().draw_mermaid_png(
            draw_method=MermaidDrawMethod.API,
        )
    )
)

Step 6: Try It Out!

Let’s test how the agent responds to different types of messages.

from langchain_core.messages import HumanMessage

messages1 = [HumanMessage(content="Hello, how are you?")]
messages2 = [HumanMessage(content="How is the temperature in Lagos?")]

graph.invoke({"messages": messages1})
graph.invoke({"messages": messages2})

You’ll see GPT-4 respond conversationally to the first, and call the weather tool for the second. 🎯

🚀 Wrap-Up

You now have a fully functioning conversational AI agent that can:

✅ Understand user intent

✅ Decide when to use external tools

✅ Fetch real-time weather data

✅ Reply intelligently using GPT-4

This is just scratching the surface. You could add more tools (news, calendar, reminders) and turn this into a real personal assistant.

Got questions or building something similar? Drop a comment below! 🧠💬

Happy coding!

Cycles and Conditional Edges in LangGraph: Controlling Workflow Execution

es404020 — Wed, 02 Apr 2025 11:43:24 +0000

When designing workflows or AI pipelines, sometimes we need to loop through certain steps multiple times before reaching an endpoint. Cycles and conditional edges in LangGraph allow us to control the flow of execution dynamically.

In this article, we’ll explore how to implement looping behavior and conditional branching using LangGraph. We'll modify the graph dynamically based on conditions to create an adaptive workflow.

Understanding Cycles and Conditional Edges

🔁 Cycles in a Graph

A cycle occurs when a node can lead back to a previous node, creating a loop. This allows repeated execution of a process until a condition is met.

🛤 Conditional Edges

Unlike standard edges, conditional edges allow dynamic routing based on input values. Instead of following a fixed path, a function determines the next node based on the current state.

Implementing Cycles and Conditional Transitions

Let’s define a state structure using TypedDict:

from typing import TypedDict
from langgraph.graph import END, StateGraph

class InputState(TypedDict):
    string_value: str
    numeric_value: int

This state includes:

string_value: A string that gets modified each cycle.
numeric_value: An integer that determines when to exit the loop.

Defining the State Modifier Node

Each time a node is visited, it updates the state:

def modify_state(input: InputState):
    input["string_value"] += "a"  # Append "a" to the string
    input["numeric_value"] += 1   # Increment the number
    return input

This function modifies the input every time it is executed.

Adding Conditional Routing

We define a router function to decide whether to continue looping or end execution:

def router(input: InputState):
    if input["numeric_value"] < 5:  # If the number is less than 5, loop back
        return "branch_a"
    else:  # Otherwise, exit the graph
        return "__end__"

Building the Graph with Cycles

Now, let’s construct the state graph:

graph = StateGraph(InputState)

# Define nodes
graph.add_node("branch_a", modify_state)
graph.add_node("branch_b", modify_state)

# Define edges
graph.add_edge("branch_a", "branch_b")  # A → B

# Conditional routing from B
graph.add_conditional_edges(
    "branch_b", router, {"branch_a": "branch_a", "__end__": END}
)

graph.set_entry_point("branch_a")  # Start from A

runnable = graph.compile()

How the Graph Works

Execution starts at branch_a.
State is modified, and control moves to branch_b.
The router function checks numeric_value:
- If less than 5, execution loops back to branch_a.
- If 5 or more, execution ends.

Visualizing the Graph

To understand the structure, we can visualize it using Mermaid diagrams:

from IPython.display import Image, display
from langchain_core.runnables.graph import MermaidDrawMethod

display(
    Image(
        runnable.get_graph().draw_mermaid_png(
            draw_method=MermaidDrawMethod.API,
        )
    )
)

This will generate a flowchart showing the looping behavior.

Why Use Cycles and Conditional Edges?

✅ Efficient looping without manually repeating code.

✅ Dynamic decision-making based on input conditions.

✅ Adaptive workflows for AI pipelines and automation.

✅ Prevents infinite loops by setting clear exit conditions.

Conclusion

In this tutorial, we explored how cycles and conditional edges enable dynamic workflow control. This is particularly useful for iterative tasks like data processing, AI feedback loops, and task automation.

Next steps? Try modifying the loop condition or adding more decision points to see how the graph behavior changes! 🚀

Building a State Graph with LangGraph: Understanding Nodes, Edges, and State

es404020 — Wed, 02 Apr 2025 11:27:41 +0000

Graphs are a fundamental data structure used to model relationships between entities. In Python, LangGraph provides an intuitive way to build stateful computation graphs, making it a powerful tool for workflows, AI pipelines, and complex state transitions.

In this blog post, we’ll explore the core concepts of Nodes, Edges, and State by implementing a simple StateGraph with LangGraph. We’ll also visualize the graph to understand its structure.

- Understanding the Core Concepts
Before diving into the code, let's break down the essential components:

🟢 Nodes (Vertices)
A node represents a point in the graph where computation or a transition occurs. It can be thought of as a function that modifies or processes data.

🔵 Edges (Connections)
An edge is a connection between nodes, defining how data flows through the graph. It determines the sequence of execution.

🟡 State (Data Structure)
State represents the information passed between nodes. In our example, we use Python’s TypedDict to define structured data.

- Defining the Graph Structure
We start by defining a TypedDict that represents the state of our system:

from typing import TypedDict

class InputState(TypedDict):
    string_value: str
    numeric_value: int

Here, InputState ensures that our state always contains a string_value (a string) and a numeric_value (an integer).

- Creating Nodes to Modify State
Each node processes the state. In this case, we define a simple function that returns the input without modification (for demonstration purposes).

def modify_state(input: InputState):
    return input

Later, we can extend this function to modify the state dynamically.

- Constructing the Graph with LangGraph
Now, let's create a StateGraph that processes data through multiple nodes.

from langgraph.graph import END, START, StateGraph

graph = StateGraph(InputState)

graph.add_node("branch_a", modify_state)
graph.add_node("branch_b", modify_state)

graph.add_edge(START, "branch_a")  # Connect START to first node
graph.add_edge("branch_a", "branch_b")  # Connect first node to second node
graph.add_edge("branch_b", END)  # Connect second node to END



runnable = graph.compile()

🔗 Breaking Down the Graph Structure

We create the graph using StateGraph(InputState), ensuring that it adheres to the InputState structure.
Nodes (branch_a, branch_b) are added—each node will process the state.

Edges define transitions:

      `START → branch_a

      branch_a → branch_b

      branch_b → END`

Setting the entry point tells the graph where execution begins.

- Visualizing the Graph
To understand the structure better, we use Mermaid diagrams to generate a visual representation of the graph.

from IPython.display import Image, display
from langchain_core.runnables.graph import MermaidDrawMethod

display(
    Image(
        runnable.get_graph().draw_mermaid_png(
            draw_method=MermaidDrawMethod.API,
        )
    )
)

This will produce a flowchart-like diagram showing the nodes and how they connect.

- Why Use LangGraph?
LangGraph makes it easy to:

Build workflows with structured state transitions.
Ensure type safety using TypedDict.
Visualize and debug complex processes.
Integrate with LangChain for AI-based applications.

Understanding TypedDict and Pydantic for Data Validation in Python

es404020 — Wed, 02 Apr 2025 09:26:55 +0000

When working with dictionaries in Python, ensuring that they contain the expected structure and types is crucial. Python provides TypedDict for type hinting, but for runtime validation, Pydantic is a more powerful solution. This article explores both approaches and highlights the advantages of using Pydantic for stricter validation.

Using TypedDict for Type Hinting

Python's TypedDict from the typing module allows us to define dictionary-like structures with predefined types. This helps with type checking but does not enforce validation at runtime.

from typing import TypedDict

class Person(TypedDict):
    name: str
    age: int

person: Person = {
    "name": "John",
    "Age": 50,  # Incorrect key capitalization
    "job_title": "Manager",  # Unexpected field
}

Issues with TypedDict

Static type checking only: The above code will not raise an error at runtime, but tools like mypy can detect issues such as:
- Incorrect key capitalization ("Age" instead of "age").
- Unexpected fields ("job_title" is not defined in Person).
No enforcement at runtime: If you run the script, it will execute without errors, meaning potential bugs may go unnoticed.

Using Pydantic for Runtime Validation

To enforce validation both at runtime and during data parsing, Pydantic is the preferred solution. Pydantic models extend BaseModel and automatically validate data when instantiated.

Here’s an improved version using Pydantic:

from pydantic import BaseModel

class Person(BaseModel):
    name: str
    age: int

person = Person(names="Eniola", age=12)  # Incorrect field name
print(person)

Advantages of Pydantic:

Runtime validation: Unlike TypedDict, Pydantic checks the data when an instance is created.
Automatic parsing: It can convert input values into the expected types.
Error detection: If an incorrect field is passed (e.g., names instead of name), Pydantic will raise an error.

Why Use Pydantic?
Pydantic is especially useful when working with frameworks like FastAPI or libraries like LangChain, where strict data validation is required for APIs and machine learning pipelines.

By integrating Pydantic, you ensure that data structures are both well-defined and rigorously validated, reducing runtime errors and improving code reliability.

LLM Distillation: Optimizing Large Language Models for Efficiency

es404020 — Thu, 13 Feb 2025 07:06:52 +0000

Large Language Models (LLMs) like OpenAI’s GPT, Google’s PaLM, and Meta’s LLaMA have transformed natural language processing (NLP), excelling in tasks such as text generation, translation, summarization, and question answering. However, their immense computational demands make them impractical for deployment on resource-constrained devices like smartphones or edge computing systems.

To overcome this challenge, researchers have developed LLM distillation, a technique that transfers knowledge from a large, complex model (the “teacher”) to a smaller, more efficient model (the “student”). This article explores LLM distillation, its workings, benefits, challenges, and real-world applications.

What is LLM Distillation?

LLM distillation, also known as knowledge distillation, is a process where a smaller model is trained to replicate the behavior of a larger, pre-trained model. The goal is to preserve the teacher model’s performance while significantly reducing the size and computational cost of the student model. This is achieved by training the student model on both the original dataset and the teacher’s outputs, known as soft labels (probability distributions over possible outputs).

First introduced by Geoffrey Hinton and colleagues in 2015, knowledge distillation has gained prominence in the era of large-scale AI models, where efficient deployment is crucial.

How Does LLM Distillation Work?

The distillation process typically follows these steps:

Training the Teacher Model: A large, high-capacity LLM is trained on extensive datasets, learning complex language patterns.
Generating Soft Labels: Instead of hard labels (discrete class assignments), the teacher produces probability distributions over possible outputs, capturing nuanced relationships between inputs and outputs.
Training the Student Model: A smaller model is trained using a combination of original data and the teacher’s soft labels. The objective is to minimize the difference between the student’s predictions and the teacher’s outputs.
Fine-Tuning: In some cases, the student model undergoes additional fine-tuning to optimize performance for specific tasks.

Benefits of LLM Distillation

LLM distillation offers several advantages, including:

Efficiency: Reduced model size and computational requirements make deployment feasible on resource-limited devices like mobile phones and IoT devices.
Speed: Smaller models enable faster inference, improving real-time applications such as chatbots, voice assistants, and machine translation.
Cost-Effectiveness: Running a distilled model requires less energy and processing power, reducing operational expenses.
Scalability: Compact models facilitate large-scale AI deployment across industries.
Knowledge Retention: Despite their smaller size, student models retain much of the teacher model’s knowledge, delivering high-quality outputs.

Challenges and Considerations

Despite its benefits, LLM distillation comes with challenges:

Performance Trade-offs: Smaller models may not fully match the capabilities of their larger counterparts, particularly for complex tasks.
Data Dependency: The quality of the student model depends on the accuracy and reliability of the teacher’s outputs. If the teacher produces biased or noisy data, the student model inherits these issues.
Task-Specific Adaptation: Some applications require additional fine-tuning, adding complexity to deployment.
Loss of Generalization: Distilled models may lose some generalization capabilities if the distillation process focuses too narrowly on specific tasks or datasets.

Applications of LLM Distillation

LLM distillation has a wide range of real-world applications, including:

Mobile & Edge Computing: Enables AI-powered NLP applications on mobile devices and smart speakers with offline functionality.
Real-Time AI Services: Enhances chatbot interactions, real-time translation, and voice assistants by improving response speed and efficiency.
Healthcare: Supports medical applications like summarizing patient records and assisting in diagnostics where computational resources are limited.
Education: Powers personalized learning tools that run efficiently on students’ devices.
Enterprise AI: Allows businesses to deploy NLP solutions for customer support, document analysis, and more—without needing extensive infrastructure.

Future Directions

As LLMs grow in size and complexity, the demand for better distillation techniques continues to rise. Researchers are exploring advanced approaches like:

Multi-Teacher Distillation: Using multiple large models to train a single student for improved generalization.
Task-Specific Distillation: Optimizing student models for particular tasks, enhancing their performance in specialized applications.
Improved Robustness & Generalization: Developing methods to ensure distilled models maintain high performance across diverse datasets.

Conclusion

LLM distillation bridges the gap between the powerful capabilities of large AI models and the practical constraints of real-world deployment. By transferring knowledge from resource-intensive models to compact, efficient versions, distillation enables broader adoption of AI across industries. As research in this field evolves, we can expect even more refined techniques, making AI both powerful and accessible in the years ahead.

Only me

es404020 — Tue, 28 Jan 2025 15:42:58 +0000

million-app-iota.vercel.app/user/login

https://firebasestorage.googleapis.com/v0/b/telleibuz-dev.appspot.com/o/4a30741e-52df-4004-84b3-5fb2de0285e3-photo.jpg?alt=media

primary:4ebdb4

{
"success": true,
"statusCode": 200,
"message": "Operation successful",
"data": {
"id": "e3aefd63-1711-4182-a2c1-7d07c9fe732b",
"brandName": "Urban skinrx",
"logo": "https://firebasestorage.googleapis.com/v0/b/telleibuz-dev.appspot.com/o/4a30741e-52df-4004-84b3-5fb2de0285e3-photo.jpg?alt=media",
"contactName": "John Doe",
"contactMobile": "1234567890",
"userId": "b1be8983-a09a-4248-9c85-e21dddbcb7f2",
"website": "https://urbanskinrx.com/",
"primaryColor": "#4ebdb4",
"secondaryColor": "#ffffff"
}
}

You are a professional dermatologist and aesthetician. Your goal is to:

Identify the user’s potential skin concerns based on their description.
Recommend products or product ingredients (with attention to their chemical composition) that can help address those concerns.
Suggest helpful dietary and lifestyle adjustments.

Important Details and Guidelines:

Provide your answers in a clear, friendly, and scientifically accurate manner.
You are not a substitute for an in-person consultation with a qualified medical professional.
Always include a disclaimer that your advice is general and may not apply to everyone.
If severe symptoms or emergencies are described, encourage the user to seek professional medical attention.
Return your response in a JSON format with the following keys:
- skin_concerns: an array listing the main skin issues identified.
- product_type_recommendation: an array of recommended product types (avoid using brand names).
- chemical_composition: an array of active ingredients or chemical compounds relevant to the recommendations.
- food_to_avoid: an array of foods that may worsen the user’s skin concerns.
- lifestyle_adjustment: an array of suggested lifestyle changes or practices to support healthier skin.
- analysisOfConcerns: a brief narrative explaining the reasoning behind your recommendations.

Structure of the JSON Response:

Building a Context-Aware To-Do List with Nestjs, RAG, Prisma, and Gemini API

es404020 — Mon, 27 Jan 2025 08:31:38 +0000

In this tutorial, we will create a context-aware to-do list application using Retrieval-Augmented Generation (RAG). We'll leverage Google's Gemini API for text embeddings, PgVector for efficient vector storage, and Prisma with NestJS for managing the PostgreSQL database. This setup will allow advanced features like cleaning up duplicate tasks and retrieving contextually similar tasks.

Prerequisites

Basic understanding of NestJS and Prisma.
Node.js and npm installed.
A PostgreSQL database with PgVector extension enabled.
Access to Google Cloud with the Gemini API key.

Step 1: Set Up NestJS Project

Create a new NestJS project:

   nest new todo-app
   cd todo-app

Remove unnecessary default files:

   rm src/app.controller.* src/app.service.* src/app.module.ts

Step 2: Install Dependencies

Install the required dependencies:

npm install prisma @prisma/client @google/generative-ai dotenv

Step 3: Configure Prisma with PgVector

Initialize Prisma:

   npx prisma init

Update the .env file with your PostgreSQL database credentials:

   DATABASE_URL="postgresql://<username>:<password>@localhost:5432/<database>?schema=public"

Enable PgVector in your schema.prisma file:

generator client {
  provider        = "prisma-client-js"
  previewFeatures = ["postgresqlExtensions"]
}

datasource db {
  provider   = "postgresql"
  url        = env("DATABASE_URL")
  extensions = [pgvector]
}

model Task {
  id        Int      @id @default(autoincrement())
  title     String
  content   String
  embedding Unsupported("vector(1536)")
}

Apply the database migration:

   npx prisma migrate dev --name init

Step 4: Configure Prisma in NestJS

Create a PrismaModule for database access:

// src/prisma/prisma.module.ts
import { Module } from '@nestjs/common';
import { PrismaService } from './prisma.service';

@Module({
  providers: [PrismaService],
  exports: [PrismaService],
})
export class PrismaModule {}

// src/prisma/prisma.service.ts
import { Injectable, OnModuleInit, OnModuleDestroy } from '@nestjs/common';
import { PrismaClient } from '@prisma/client';

@Injectable()
export class PrismaService extends PrismaClient implements OnModuleInit, OnModuleDestroy {
  async onModuleInit() {
    await this.$connect();
  }

  async onModuleDestroy() {
    await this.$disconnect();
  }
}

Import the PrismaModule in your main module:

// src/app.module.ts
import { Module } from '@nestjs/common';
import { PrismaModule } from './prisma/prisma.module';
import { TasksModule } from './tasks/tasks.module';

@Module({
  imports: [PrismaModule, TasksModule],
})
export class AppModule {}

Step 5: Set Up the Tasks Module

Generate the tasks module:

   nest generate module tasks
   nest generate service tasks
   nest generate controller tasks

Implement the TasksService:

   // src/tasks/tasks.service.ts
   import { Injectable } from '@nestjs/common';
   import { PrismaService } from '../prisma/prisma.service';
   import { Task } from '@prisma/client';
   import { GeminiService } from '../gemini/gemini.service';

   @Injectable()
   export class TasksService {
     constructor(private prisma: PrismaService, private geminiService: GeminiService) {}

     async createTask(title: string, content: string): Promise<Task> {
       const embedding = await this.geminiService.getEmbedding(`${title} ${content}`);
       return this.prisma.task.create({
         data: { title, content, embedding },
       });
     }

     async getTasks(): Promise<Task[]> {
       return this.prisma.task.findMany();
     }

     async findSimilarTasks(embedding: number[], limit = 5): Promise<any[]> {
       const embeddingStr = `[${embedding.join(',')}]`;
       return this.prisma.$queryRaw`
         SELECT *, embedding <-> ${embeddingStr}::vector AS distance
         FROM "Task"
         ORDER BY embedding <-> ${embeddingStr}::vector
         LIMIT ${limit};
       `;
     }
   }

Implement the TasksController:

   // src/tasks/tasks.controller.ts
   import { Controller, Post, Get, Body } from '@nestjs/common';
   import { TasksService } from './tasks.service';

   @Controller('tasks')
   export class TasksController {
     constructor(private tasksService: TasksService) {}

     @Post()
     async createTask(@Body('title') title: string, @Body('content') content: string) {
       return this.tasksService.createTask(title, content);
     }

     @Get()
     async getTasks() {
       return this.tasksService.getTasks();
     }
   }

Step 6: Integrate Gemini API for Embedding Generation

Create a GeminiService:

   // src/gemini/gemini.service.ts
   import { Injectable } from '@nestjs/common';
   import * as genai from '@google/generative-ai';

   @Injectable()
   export class GeminiService {
     private client: genai.GenerativeLanguageServiceClient;

     constructor() {
       this.client = new genai.GenerativeLanguageServiceClient({
         apiKey: process.env.GEMINI_API_KEY,
       });
     }

     async getEmbedding(text: string): Promise<number[]> {
       const result = await this.client.embedText({
         model: 'models/text-embedding-001',
         content: text,
       });
       return result.embedding;
     }
   }

Final Thoughts

With this setup, you have a fully functional to-do list application that can:

Generate embeddings for task content using Gemini.
Store embeddings in a PostgreSQL database using PgVector.
Retrieve similar tasks based on their embeddings.

This architecture enables advanced features like semantic search and contextual data cleaning. Expand it further to build intelligent task management systems!

Building Intelligent Agents with LangChain and OpenAI: A Developer's Guide

es404020 — Mon, 20 Jan 2025 06:53:19 +0000

As artificial intelligence advances, developers are exploring ways to integrate intelligence into everyday workflows. One such approach involves building agents capable of executing tasks autonomously, combining reasoning with action. In this article, we’ll explore how to create intelligent agents using LangChain, OpenAI’s GPT-4, and LangChain’s experimental tools. These agents will be able to execute Python code, interact with CSV files, and answer complex queries. Let’s dive in!

Why LangChain?

LangChain is a powerful framework for building applications that leverage language models. It’s particularly useful for creating modular and reusable components, such as agents, that can:

Execute Python code.
Analyze and interact with data files.
Perform reasoning and decision-making tasks using tools.

By combining LangChain’s capabilities with OpenAI’s GPT-4, we can create agents tailored to specific use cases, like data analysis, debugging, and more.

Getting Started

Before we dive into the code, ensure your environment is set up with the necessary tools. Here’s what you’ll need:

Install Python libraries:

pip install langchain langchain-openai python-dotenv

Create a .env file to securely store your OpenAI API key:

OPENAI_API_KEY=your_api_key_here

Building the Python Execution Agent

One of the key capabilities of our agent is executing Python code. This is achieved using LangChain’s PythonREPLTool. Let’s start by defining the agent.

Instruction Design

The agent operates based on a set of instructions. Here’s the prompt we’ll use:

instruction = """
You are an agent designed to write and execute Python code to answer questions.
You have access to Python REPL, which you can use to execute Python code.
If you get an error, debug your code and try again.
Only use the output of your code to answer the question.
If you cannot write code to answer the question, return 'I don't know' as the answer.

Setting Up the Agent

We’ll use LangChain’s REACT framework to build this agent:

from langchain import hub
from langchain_openai import ChatOpenAI
from langchain_experimental.tools import PythonREPLTool
from langchain.agents import create_react_agent, AgentExecutor

base_prompt = hub.pull("langchain-ai/react-agent-template")
prompt = base_prompt.partial(instructions=instruction)

tools = [PythonREPLTool()]
python_agent = create_react_agent(
    prompt=prompt,
    llm=ChatOpenAI(temperature=0, model="gpt-4-turbo"),
    tools=tools,
)
python_executor = AgentExecutor(agent=python_agent, tools=tools, verbose=True)

This agent can now execute Python code and return the results.

Enhancing the Agent with CSV Analysis

Data analysis is a common use case for AI agents. By integrating LangChain’s create_csv_agent, we can enable our agent to query and process data from CSV files.

Setting Up the CSV Agent

Here’s how to add CSV capabilities to the agent:


from langchain_experimental.agents.agent_toolkits import create_csv_agent

csv_agent = create_csv_agent(
    llm=ChatOpenAI(temperature=0, model="gpt-4-turbo"),
    path="episode-info.csv",
    verbose=True,
    allow_dangerous_code=True,
)

This agent can now answer questions about the contents of episode-info.csv, such as:

How many rows and columns does the file have?
What season has the most episodes?

Combining Tools into a Unified Agent

To create a versatile agent, we’ll combine the Python execution and CSV analysis capabilities into a single entity. This allows the agent to seamlessly switch between tools based on the task.

Defining the Unified Agent

from langchain.agents import Tool

def python_executor_wrapper(prompt: str):
    python_executor.invoke({"input": prompt})

tools = [
    Tool(
        name="Python Agent",
        func=python_executor_wrapper,
        description="""
        Useful for transforming natural language to Python code and executing it.
        DOES NOT ACCEPT CODE AS INPUT.
        """
    ),
    Tool(
        name="CSV Agent",
        func=csv_agent.invoke,
        description="""
        Useful for answering questions about episode-info.csv by running pandas calculations.
        """
    ),
]

grant_agent = create_react_agent(
    prompt=base_prompt.partial(instructions=""),
    llm=ChatOpenAI(temperature=0, model="gpt-4-turbo"),
    tools=tools,
)
grant_agent_executor = AgentExecutor(agent=grant_agent, tools=tools, verbose=True)

This combined agent is now capable of answering questions about both Python logic and CSV data analysis.

Practical Example: Analyzing TV Show Episodes

Let’s see the unified agent in action by querying episode-info.csv.

print(
    grant_agent_executor.invoke({
        "input": "What season has the most episodes?"
    })
)

The agent will analyze the CSV file and return the season with the highest episode count, leveraging pandas under the hood.

Next Steps

Experiment with additional tools and datasets.
Explore LangChain’s documentation to build even more powerful agents.

LangChain opens the door to creating highly customized, intelligent agents that can simplify complex workflows. With tools like the Python REPL and CSV agent, the possibilities are endless—from automating data analysis to debugging code and beyond. Start building your intelligent agent today!

DEV Community: es404020

Building a Custom Screen Time Flutter App with iOS Native APIs

Core Architecture: The Flutter-to-iOS Bridge

Step 1: The Flutter Service (screen_time_bridge.dart)

Step 2: The Native Swift Implementation

Handling the App Picker using SwiftUI

Applying Shields & Blocking Apps

Monitoring Usage Limits and The 15-Minute Rule

🛑 Critical Production Constraint: Required Entitlements

A Gentle, Fun, and Professional Guide to Q‑Learning and Epsilon‑Greedy

🧠 What Is Q‑Learning?

📘 The Famous Q‑Learning Formula

What does it mean in normal-human English?

🎲 What Is Epsilon‑Greedy?

Example (with cartoons!)

📜 Short History of Q‑Learning (Fun Version)

📅 1950s — The Ancestors

📅 1989 — Chris Watkins Creates Q‑Learning

📅 2015 — DeepMind Makes It Cool

📅 Today

🤖 Why People Love Q‑Learning

🎨 Simple Visual Concept Diagram

📂 Summary

🎉 Final Thoughts

Bracket Matching / Valid Parentheses

Problem Statement

Original JavaScript Implementation

Explanation Line-by-Line

Example Usages

Time and Space Complexity

Conclusion

[Boost]

Building a Weather-Savvy AI Agent Using LangGraph, LangChain, and OpenAI

Building a Weather-Savvy AI Agent Using LangGraph, LangChain, and OpenAI

📦 Requirements

🧠 The Code

Step 1: Set Up Environment & Imports

Step 2: Create a Weather Tool 🌡️

Step 3: Connect Tools to the Model

Step 4: Create the Agent Workflow using LangGraph

Step 5: Visualize the Workflow 🌐

Step 6: Try It Out!

🚀 Wrap-Up

Cycles and Conditional Edges in LangGraph: Controlling Workflow Execution

Understanding Cycles and Conditional Edges

🔁 Cycles in a Graph

🛤 Conditional Edges

Implementing Cycles and Conditional Transitions

Defining the State Modifier Node

Adding Conditional Routing

Building the Graph with Cycles

How the Graph Works

Visualizing the Graph

Why Use Cycles and Conditional Edges?

Conclusion

Building a State Graph with LangGraph: Understanding Nodes, Edges, and State

Understanding TypedDict and Pydantic for Data Validation in Python

LLM Distillation: Optimizing Large Language Models for Efficiency

What is LLM Distillation?

How Does LLM Distillation Work?

Benefits of LLM Distillation

Challenges and Considerations

Applications of LLM Distillation

Future Directions

Conclusion

Only me

Building a Context-Aware To-Do List with Nestjs, RAG, Prisma, and Gemini API

Prerequisites

Step 1: Set Up NestJS Project

Step 2: Install Dependencies

Step 3: Configure Prisma with PgVector

Step 4: Configure Prisma in NestJS

Step 5: Set Up the Tasks Module

Step 6: Integrate Gemini API for Embedding Generation

Final Thoughts

Building Intelligent Agents with LangChain and OpenAI: A Developer's Guide

Step 1: The Flutter Service (`screen_time_bridge.dart`)