Dev.to tutorials describe LangGraph-based AI agents for medical triage, analysis, and automation

We've all been there: staring at a clunky, 10-year-old hospital web portal, clicking through endless nested menus just to book a simple check-up or download a PDF lab result. It's tedious, error-prone, and frankly, a waste of human potential. But what if you could just tell an AI, "Book me a dermatologist for next Tuesday and save my blood test results to my health folder," and it just... did it? In this tutorial, we are diving deep into the world of autonomous agents, GPT-4o, and LLM-driven web navigation. By leveraging the revolutionary Browser-use library and Playwright, we’ll build a vision-capable agent that can navigate complex UIs, handle logins, and automate the most frustrating parts of healthcare administration. 🚀 Why Traditional Scraping Fails (and Why Agents Win) Traditional automation tools like Selenium or Puppeteer rely on brittle DOM selectors (#button-id-342). When a hospital updates its website, your script breaks. Using Browser-use with GPT-4o changes the game. Instead of looking for code, the agent sees the page like a human, understanding that a magnifying glass icon means "Search" regardless of the underlying HTML. The Architecture 🏗️ The system logic involves a feedback loop where the LLM perceives the browser state (screenshot + DOM tree), decides on an action, and executes it via Playwright. graph TD A[User Goal: Book Appointment/Download Report] --> B[LangChain Agent / Browser-use] B --> C{Decision Engine: GPT-4o} C --> D[Action: Click/Type/Scroll] D --> E[Playwright Browser Instance] E --> F[Hospital Portal UI] F --> G[Visual & HTML Feedback] G --> C F --> H[Download Lab Report PDF] H --> I[Structured Storage / RAG Pipeline] I --> J[Task Completed ✅] Prerequisites 🛠️ Before we start, ensure you have the following in your tech stack: Python 3.10+ Playwright (The backbone of browser control) Browser-use (The bridge between LLMs and browsers) OpenAI API Key (We'll use GPT-4o for its superior vision capabilities) pip install browser-use playwright langchain-openai playwright install Step 1: Initialize the Browser Agent The core of our solution is the Agent class from the browser-use library. It wraps the browser interactions into a "thought-action" loop. from browser_use import Agent from langchain_openai import ChatOpenAI import asyncio async def run_healthcare_agent(): # Initialize our LLM (GPT-4o is highly recommended for visual UI tasks) llm = ChatOpenAI(model="gpt-4o") # Define the mission task = ( "1. Go to 'https://portal.city-hospital.com' and login. " "2. Navigate to the 'My Appointments' section. " "3. Find the first available slot for 'General Practitioner' next week. " "4. Then, go to 'Lab Results', find the latest PDF, and download it." ) agent = Agent( task=task, llm=llm, ) history = await agent.run() print(history[-1].result) if __name__ == "__main__": asyncio.run(run_healthcare_agent()) Step 2: Handling Secure Logins and Downloads Healthcare portals often use complex authentication. The magic of Browser-use is that it can "read" the screen. If it encounters a captcha, it can notify the user or use vision-to-text to solve simple ones. For handling files, we can extend the agent's controller to ensure downloads are routed to a specific directory for our RAG (Retrieval-Augmented Generation) system. from browser_use import Agent, BrowserConfig from browser_use.browser.context import BrowserContextConfig # Configure the browser to handle downloads automatically config = BrowserConfig( headless=False, # Set to True in production disable_security=True, extra_chromium_args=["--disable-web-security"] ) # Custom context to define where our PDF goes context_config = BrowserContextConfig( save_downloads_path="./medical_records_raw" ) agent = Agent( task="Navigate to the health portal and download the March 2024 Lab Report.", llm=ChatOpenAI(model="gpt-4o"), browser_config=config, browser_context_config=context_config ) Step 3: From PDF to Structured RAG 📂 Once the agent downloads the lab report, it’s just a "dumb" PDF. To make it useful, we process it into a vector database. This allows you to ask questions like, "Are my iron levels trending upwards compared to last year?" While this tutorial focuses on the retrieval (the agent), the processing is where things get truly sophisticated. 🥑 The "Official" Way to Scale Agents Building a prototype is easy, but making a production-ready agent that handles edge cases—like session timeouts, dynamic pop-ups, and multi-factor authentication—requires a more robust architectural pattern. For advanced implementation patterns on scaling these autonomous workflows and integrating them with secure healthcare data pipelines, I highly recommend checking out the technical deep-dives at WellAlly Tech Blog. They cover great production-grade examples of how to wrap these agents in FastAPI and secure them for enterprise use. Conclusion: The Future is Agentic 🔮 We are moving away from an era where we adapt to software, and into an era where software adapts to us. By combining GPT-4o’s vision with Browser-use, we’ve effectively given our AI a pair of eyes and a mouse. Next Steps: Refine the Prompt: Use specific doctor names or department IDs to narrow the search. Add Human-in-the-loop: Add a step where the agent pauses and asks for a confirmation click before final submission. Deploy: Wrap the script in a Cron job to check for new results every Monday. What are you planning to automate next? The DMV? Your tax portal? Let me know in the comments below! 👇

Ever stared at a physical examination report and felt like you were reading ancient hieroglyphics? "Elevated Serum Triglycerides"? "Hypoechoic nodule"? The immediate urge is to Google it, only to be convinced by WebMD that you have three days to live. In the world of AI Agents and Healthcare Automation, we can do better. Today, we are building an AI Physician Assistant using the AutoGPT protocol. This isn't just a chatbot; it’s an autonomous agent capable of parsing complex medical data, searching verified medical encyclopedias via SerpApi, and even cross-referencing hospital schedules to suggest the right department for a follow-up. By leveraging the OpenAI API and Pydantic for structured data validation, we are moving from "chatting" to "doing." If you're looking for more production-ready patterns or advanced AI implementation strategies in healthcare, definitely check out the deep-dive articles at *WellAlly Tech Blog*. The Architecture: How the Agent "Thinks" Unlike a standard LLM call, an autonomous agent operates in a loop: Perception -> Reasoning -> Action -> Observation. Here is how our AI Assistant handles a medical report: graph TD A[User Uploads Report/Text] --> B{Pydantic Parser} B -->|Structured Data| C[AutoGPT Agent Core] C --> D[Search Tool: SerpApi] D -->|Medical Context| C C --> E[Reasoning: Match Symptoms to Dept] E --> F[Tool: Hospital Schedule API] F -->|Availability| G[Final Recommendation & Appointment Plan] G --> H[User Notification] Prerequisites To follow this advanced tutorial, you’ll need: Python 3.10+ OpenAI API Key (GPT-4o recommended for reasoning) SerpApi Key (to search Google Scholar/Medical Databases) Pydantic for data modeling Step 1: Defining the Medical Schema (Pydantic) The biggest challenge in medical automation is data integrity. We cannot allow the AI to hallucinate vital signs. We use Pydantic to ensure the agent only proceeds if the data matches our schema. from pydantic import BaseModel, Field from typing import List, Optional class MedicalFinding(BaseModel): term: str = Field(..., description="The medical term or indicator name") value: str = Field(..., description="The numerical or qualitative result") is_abnormal: bool = Field(..., description="True if the value is outside the reference range") suggested_specialty: Optional[str] = None class HealthReport(BaseModel): patient_id: str findings: List[MedicalFinding] summary: str Step 2: The Agent's Toolkit (SerpApi & Reasoning) We need to give our agent "eyes" to the outside world. Using SerpApi, the agent can look up the latest clinical guidelines for specific abnormalities. import os from serpapi import GoogleSearch def medical_knowledge_search(query: str): """Searches medical databases for term clarification.""" params = { "engine": "google", "q": f"medical definition and clinical significance of {query}", "api_key": os.getenv("SERPAPI_KEY") } search = GoogleSearch(params) results = search.get_dict() return results.get("organic_results", [{}])[0].get("snippet", "No info found.") Step 3: Implementing the AutoGPT Loop Now, we define the agent logic. We use a "Chain of Thought" prompt that forces the agent to plan its search before making a recommendation. import openai def ai_physician_assistant(report_text: str): # Initial Parsing system_prompt = ( "You are an AI Physician Assistant. Your goal is to: " "1. Extract abnormal findings. 2. Research their clinical meaning. " "3. Recommend the correct hospital department. " "Use a structured JSON format for your final output." ) # Simple representation of the Agent's autonomous loop response = openai.chat.completions.create( model="gpt-4o", messages=[ {"role": "system", "content": system_prompt}, {"role": "user", "content": f"Analyze this report: {report_text}"} ], response_format={ "type": "json_object" } ) return response.choices[0].message.content # Example usage raw_report = "Patient exhibits ALT levels of 85 U/L and mild fatty liver on ultrasound." result = ai_physician_assistant(raw_report) print(result) Going Beyond the Basics: Production Patterns Building a hobby project is one thing; building a reliable AI medical tool is another. In a production environment, you need to handle: PII Redaction: Never send Patient Identifiable Information to a public LLM. Human-in-the-loop (HITL): An agent should "flag" results for a human doctor's review rather than diagnosing autonomously. Prompt Versioning: Medical guidelines change, and your prompts should too. For more advanced patterns on handling HIPAA-compliant AI workflows and multi-agent orchestration, I highly recommend exploring the specialized resources at WellAlly Tech Blog. They offer fantastic insights into how these technologies are being applied in real-world enterprise healthcare environments. Conclusion By combining AutoGPT's autonomous reasoning with Pydantic's strict validation, we've created a tool that transforms scary medical jargon into actionable health plans. The future of healthcare isn't just about better medicine; it's about better information accessibility. AI agents are the bridge between complex clinical data and patient peace of mind. What are you building next? Drop a comment below or share your thoughts on AI safety in healthcare! 🚀

Imagine your smartwatch detects an irregular heart rhythm at 3 AM. Instead of just waking you up with a frantic "beep," an AI agent immediately analyzes your historical health data, searches for the best cardiologist nearby, and prepares a calendar invite for a consultation. This isn't science fiction—it's the power of Healthcare Automation driven by AI Agents. In this tutorial, we are diving deep into LangGraph, the cutting-edge framework for building stateful, multi-agent applications. We’ll explore how to use State Machines to orchestrate a complex medical workflow, moving from an "Abnormal Heart Rate Alert" to a "Specialist Appointment" using the Tavily API for research and Twilio for urgent notifications. By the end of this guide, you’ll understand how to manage non-linear LLM workflows that require reliability and precision. The Architecture: Why LangGraph? Traditional LLM chains are linear. But medical emergencies are not. They require loops, conditional branching (e.g., "Is this an emergency or a routine check-up?"), and state persistence. LangGraph allows us to define a graph where each node is a function and edges define the transition logic. Data Flow Overview The following diagram illustrates how our agent processes a heart rate alert: graph TD A[Start: Heart Rate Alert] --> B{Severity Triage} B -- Emergency --> C[Twilio: Alert Emergency Services] B -- High Risk --> D[Tavily API: Find Best Specialist] B -- Normal/Review --> E[Log to Health Records] D --> F[Google Calendar: Draft Appointment] F --> G[Twilio: SMS Patient Confirmation] C --> H[End] G --> H E --> H Prerequisites 🛠️ To follow along with this advanced tutorial, you'll need: Python 3.10+ LangGraph & LangChain: The orchestration engine. Tavily API Key: For searching local medical specialists. Twilio Account: For SMS/Voice alerting. An OpenAI API Key (GPT-4o is recommended for medical reasoning). Step 1: Defining the Agent State In LangGraph, the State is a shared schema that evolves as it moves through nodes. For our medical agent, we need to track the patient's heart rate, the triage decision, and the suggested doctor. from typing import Annotated, TypedDict, List from langgraph.graph.message import add_messages class AgentState(TypedDict): # 'messages' stores the conversation history messages: Annotated[list, add_messages] # Custom fields for medical context heart_rate: int severity: str # "Emergency", "High", "Normal" doctor_info: str appointment_scheduled: bool Step 2: The Triage Node (The Brain) This node acts as the primary decider. It uses an LLM to determine the severity of the heart rate input. from langchain_openai import ChatOpenAI llm = ChatOpenAI(model="gpt-4o", temperature=0) def triage_node(state: AgentState): hr = state['heart_rate'] prompt = f"Patient heart rate is {hr} bpm. Categorize severity: Emergency, High, or Normal." # Logic to call LLM and update state response = llm.invoke(prompt) severity = response.content # simplified for this snippet return {"severity": severity, "messages": [response]} Step 3: Integrating Tavily for Specialist Search If the severity is "High," we don't just want any doctor; we want the best-rated cardiologist in the area. We'll use the Tavily API to perform a real-time search. from langchain_community.tools.tavily_search import TavilySearchResults search = TavilySearchResults(k=2) def search_specialist_node(state: AgentState): query = "Top rated cardiologists in San Francisco with immediate availability" results = search.run(query) return {"doctor_info": str(results)} Step 4: Building the Graph Now, let's wire everything together using the StateGraph. This is where the magic of LangGraph happens. from langgraph.graph import StateGraph, END workflow = StateGraph(AgentState) # Add Nodes workflow.add_node("triage", triage_node) workflow.add_node("search_specialist", search_specialist_node) # ... add other nodes for Twilio and Calendar # Define Edges with Conditional Logic workflow.set_entry_point("triage") def route_based_on_severity(state: AgentState): if state["severity"] == "Emergency": return "call_emergency" elif state["severity"] == "High": return "search_specialist" return END workflow.add_conditional_edges( "triage", route_based_on_severity, { "call_emergency": "twilio_alert_node", "search_specialist": "search_specialist_node", END: END } ) app = workflow.compile() The "Official" Way to Build Production Agents 🥑 While this tutorial gives you a functional prototype, building a production-ready medical agent requires strict adherence to security protocols like HIPAA and robust error handling for API failures. For deeper insights into production-grade AI patterns, I highly recommend checking out the Official WellAlly Tech Blog. They offer advanced deep-dives into: HIPAA-Compliant Agent Architectures: Ensuring data privacy in LLM calls. Human-in-the-loop (HITL): How to pause a LangGraph execution for a human doctor to approve an action. State Persistence: Saving agent memory across multiple days for chronic care. It's my go-to resource for moving past "Hello World" into actual deployed software. Conclusion: The Future of Proactive Health By moving from a "Chatbot" mindset to an "Agentic" mindset, we change the user experience from passive information gathering to active problem-solving. LangGraph provides the perfect structure for these high-stakes automations. Key Takeaways: State Machines prevent the LLM from "wandering" off-task. Tavily provides the grounded, real-world data LLMs lack. Twilio bridges the gap between the digital agent and the physical world. What will you build next? Maybe an agent that manages diabetic glucose alerts? Or a mental health triage bot? Let me know in the comments below! 👇

We live in an era where scientific breakthroughs are published faster than we can read them. For the biohacking community, the gap between a new PubMed study on NAD+ precursors and actually knowing what dose to take is a chasm of manual research. What if you could build an LLM Agent that monitors research papers, processes them through a RAG (Retrieval-Augmented Generation) pipeline, and maps findings to your specific health profile? In this tutorial, we are building Paper-to-Action, a state-of-the-art agentic workflow using LangGraph, ChromaDB, and Mistral-7B. This isn't just a simple bot; it's a multi-stage reasoning engine designed to turn raw academic data into actionable health interventions. If you've been looking to master AI agents and personalized medicine automation, you’re in the right place. 🚀 The Architecture: From Raw Paper to Personalized Habit Traditional RAG pipelines are linear. To handle the nuance of medical research, we need a "looping" logic. We use LangGraph to manage the state of our agent, allowing it to decide if a paper is relevant before attempting to extract a protocol. System Flow graph TD A[Start: Keyword Trigger] --> B[Search PubMed/Arxiv API] B --> C{Relevance Filter} C -- No --> B C -- Yes --> D[Store in ChromaDB] D --> E[RAG: Extract Intervention Protocol] E --> F[Cross-Reference with User Profile] F --> G[Generate Personalized Action Plan] G --> H[End: Push to Health Checklist] Prerequisites To follow this advanced guide, you'll need: LangGraph: For the agentic state machine. ChromaDB: As our high-performance vector store. Mistral-7B: Running via Ollama or vLLM for local, private inference. Python 3.10+ Step 1: Defining the Agent State In LangGraph, everything revolves around the State. We need to track the fetched papers, the extracted data, and the final recommendation. from typing import Annotated, List, TypedDict from langgraph.graph import StateGraph, END class AgentState(TypedDict): keywords: List[str] user_profile: dict raw_papers: List[dict] extracted_protocols: List[dict] final_recommendation: str Step 2: The Research Fetcher (Arxiv/PubMed Integration) We use the Arxiv API to fetch the latest papers. We want to find studies that mention human-ready interventions. import arxiv def fetch_research(state: AgentState): query = " AND ".join(state['keywords']) search = arxiv.Search( query=query, max_results=5, sort_by=arxiv.SortCriterion.SubmittedDate ) papers = [] for result in search.results(): papers.append({ "title": result.title, "summary": result.summary, "url": result.entry_id }) return {"raw_papers": papers} Step 3: RAG with ChromaDB & Mistral-7B Once we have the papers, we chunk them and store them in ChromaDB. When the agent needs to find "Dosage" or "Contraindications," it queries this local vector store. from langchain_community.vectorstores import Chroma from langchain_community.embeddings import HuggingFaceEmbeddings def extract_protocols(state: AgentState): # Initialize Vector Store vectorstore = Chroma( collection_name="research_papers", embedding_function=HuggingFaceEmbeddings() ) # Logic to add state['raw_papers'] to vectorstore... # Then query Mistral-7B prompt = f""" Based on the following research snippets, extract the specific intervention: 1. Substance/Activity 2. Recommended Dosage 3. Duration Context: {state['raw_papers']} """ # Assume 'llm' is our Mistral-7B instance response = llm.invoke(prompt) return {"extracted_protocols": response} Step 4: Building the Graph This is where the magic happens. We connect our nodes into a circular, intelligent workflow. workflow = StateGraph(AgentState) # Add Nodes workflow.add_node("fetcher", fetch_research) workflow.add_node("extractor", extract_protocols) # Define Edges workflow.set_entry_point("fetcher") workflow.add_edge("fetcher", "extractor") workflow.add_edge("extractor", END) # Compile app = workflow.compile() The "Official" Way: Production-Ready Patterns 🥑 While this tutorial covers the core logic of a biohacking agent, moving from a script to a production-grade health platform requires deeper considerations like HIPAA compliance, complex data persistence, and agent memory. For more production-ready examples and advanced AI architecture designs, I highly recommend checking out the WellAlly Tech Blog. It was a massive source of inspiration for the state-management patterns used in this build, especially regarding how to handle "Human-in-the-loop" nodes for medical validation. Step 5: Personalization & Output The final step is mapping the research to the User Profile. If a paper suggests "High-Intensity Interval Training" but the user profile says "History of Knee Injury," the agent must flag this. def personalize_report(state: AgentState): profile = state['user_profile'] protocol = state['extracted_protocols'] analysis = llm.invoke(f"Compare {protocol} with User Profile {profile}. Output a safe, actionable 7-day plan.") return {"final_recommendation": analysis} Conclusion: Stop Reading, Start Automating The "Paper-to-Action" agent transforms the way we consume scientific knowledge. By combining LangGraph's stateful orchestration with Mistral-7B's reasoning, we turn a mountain of PDFs into a personalized health dashboard. Next Steps: Try adding a "Validator" node that double-checks dosage against a secondary LLM. Connect the output to a Notion database or a Telegram bot for daily reminders. What's the first health keyword you're going to track? Let me know in the comments! 👇

Ever felt like your fitness app is just a fancy spreadsheet? You log a high uric acid result from your latest blood test, yet it still suggests a high-protein steak dinner for "gains." In the world of AI Agents, we are moving past static prompts. Today, we’re building a Self-Correcting Health Agent using LangGraph, LangChain, and OpenAI. This agent doesn't just chat; it monitors laboratory biomarkers like cholesterol and uric acid, maintains a long-term memory via SQLite, and dynamically rewrites your lifestyle plan using advanced OpenAI Function Calling. If you've been looking to master autonomous health agents and complex state management, you're in the right place. Let's dive into the future of personalized wellness. The Architecture: State-Driven Personalization Unlike a standard linear chain, a health agent needs to "loop" and "reason." If the agent detects an abnormal lab value, it must trigger a specific logic branch to revise existing plans. Here is how the data flows through our LangGraph system: graph TD A[User Input/Lab Report] --> B{Analyze Biomarkers} B -- Abnormal Found --> C[Tool: Plan Rewriter] B -- All Normal --> D[Tool: Maintenance Plan] C --> E[Update SQLite Memory] D --> E[Update SQLite Memory] E --> F[Output Final Recommendation] F --> G[Wait for Next Input] G -- New Data --> B Prerequisites To follow along, you'll need: LangGraph & LangChain: For orchestration. OpenAI API: For the reasoning engine (GPT-4o recommended). SQLite: To handle persistent state and "memory" of your health journey. Step 1: Defining the Agent State In LangGraph, the State is the source of truth. We need to track the user's current health metrics and their active diet plan. from typing import Annotated, TypedDict, List from langgraph.graph import StateGraph, END import operator class HealthState(TypedDict): # We use operator.add to keep a history of logs logs: Annotated[List[str], operator.add] biomarkers: dict current_diet_plan: str revision_required: bool Step 2: Crafting the "Logic Brain" (The Nodes) The magic happens when the LLM decides whether your lab results require a "Protocol Pivot." We use OpenAI's Function Calling to detect high uric acid or cholesterol. from langchain_openai import ChatOpenAI from langchain_core.messages import HumanMessage llm = ChatOpenAI(model="gpt-4o", temperature=0) def analyze_labs(state: HealthState): biomarkers = state['biomarkers'] # Logic to determine if intervention is needed needs_fix = False if biomarkers.get("uric_acid", 0) > 420: # Example threshold needs_fix = True return {"revision_required": needs_fix, "logs": ["Analyzed lab results..."]} def rewrite_diet_plan(state: HealthState): prompt = f"Adjust the following diet plan based on these biomarkers: {state['biomarkers']}. Current Plan: {state['current_diet_plan']}" # The LLM generates a new plan avoiding high-purine/high-fat foods new_plan = llm.invoke([HumanMessage(content=prompt)]) return {"current_diet_plan": new_plan.content, "logs": ["Diet plan updated for health safety."]} Step 3: Wiring the Graph Now, we connect the nodes. We use a conditional edge to decide whether to go to the rewrite_diet_plan node or straight to the end. workflow = StateGraph(HealthState) workflow.add_node("analyzer", analyze_labs) workflow.add_node("rewriter", rewrite_diet_plan) workflow.set_entry_point("analyzer") # Conditional Logic: If revision_required is True, go to rewriter workflow.add_conditional_edges( "analyzer", lambda x: "rewrite" if x["revision_required"] else "end", { "rewrite": "rewriter", "end": END } ) workflow.add_edge("rewriter", END) # Compile with persistence (SQLite) from langgraph.checkpoint.sqlite import SqliteSaver memory = SqliteSaver.from_conn_string(":memory:") app = workflow.compile(checkpointer=memory) The "Official" Way to Build AI Agents 🚀 While this tutorial covers the core logic of stateful agents, building medical-grade or production-ready health platforms requires deeper security and more robust validation patterns. For advanced architectural patterns on deploying AI agents in high-stakes environments, I highly recommend checking out the WellAlly Blog. They provide excellent deep dives into integrating AI with real-world health data and "Agentic Workflows" that go far beyond basic tutorials. Step 4: Running the Agent Let's test it with a scenario: A user with a "Keto" plan suddenly uploads a lab report showing high cholesterol. config = {"configurable": {"thread_id": "user_123"}} initial_input = { "biomarkers": {"cholesterol": 280, "uric_acid": 450}, "current_diet_plan": "High protein, high fat Keto diet.", "logs": [] } for event in app.stream(initial_input, config): for value in event.values(): print(f"Update: {value.get('logs', '')}") if 'current_diet_plan' in value: print(f"New Plan: {value['current_diet_plan']}") Why this works: Memory: By using thread_id, the agent remembers the previous state. Safety: We can inject hardcoded medical constraints into the analyzer node before the LLM even sees the data. Flexibility: Adding a new biomarker (like Vitamin D) just requires adding a new node or updating the tool schema. Conclusion Building autonomous health agents with LangGraph transforms a simple chatbot into a proactive health companion. By moving the logic into a directed graph, we gain control over the "reasoning loops" that LLMs often struggle with. What's next for your agent? Add a "Supplement Checker" tool. Integrate with a Google Calendar API to schedule the new meal plan. Use WellAlly's production patterns to scale your agent to thousands of users. Happy coding, and stay healthy! 🚀💻🥑 Have questions about LangGraph or Agent memory? Drop a comment below!