You can deploy this model and start earning money today!

Medical Function-Calling LLM (Fine-tuned DeepSeek-R1-Distill-Qwen-1.5B)

This model is a fine-tuned version of deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B, specialized for medical domain function-calling tasks.
It is trained on Salesforce/xlam-function-calling-60k to reliably produce structured JSON outputs for healthcare applications such as appointment booking, medical record retrieval, patient communication, and medical triage support.

Model Details

Developed by: Alton Lavin D’Souza
Funded by: Self-funded
Model type: Instruction-tuned causal language model with function-calling capabilities
Language(s): English
License: MIT
Finetuned from model: deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B

Model Sources

Repository: GitHub – Medical Function Calling LLM
Base model card: DeepSeek-R1-Distill-Qwen-1.5B

Uses

Direct Use

Conversational AI assistants in healthcare
Automated structured response generation in JSON
Integration with electronic health record (EHR) systems
Medical workflow automation (e.g., booking appointments, retrieving patient data)

Downstream Use

Fine-tuning for specific healthcare specialties
Integration into clinical decision support systems
Agent-based medical AI systems with tool use

Out-of-Scope Use

Direct diagnosis without human oversight
Emergency medical response without clinician involvement
General-purpose non-medical applications (may work but not optimized)

Bias, Risks, and Limitations

This model may:

Hallucinate medical facts if prompted outside its training scope
Produce incomplete JSON structures if instructions are ambiguous
Require strict validation before integration into real-world healthcare systems

⚠️ Important: This model is not a substitute for a licensed medical professional.

Tool Calling Example:

python

import json
import os
import pickle
import time
from datetime import datetime, timedelta ,time as time_1
from threading import Thread
from typing import TypedDict, Dict, List, Any
from urllib.request import Request

import pytz
import torch
from duckduckgo_search import DDGS
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build
from langchain_community.tools import TavilySearchResults
from langgraph.constants import START, END
from langgraph.graph import StateGraph
from regex import regex, search
from smolagents import DuckDuckGoSearchTool
from sympy.physics.units.definitions.dimension_definitions import information
from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer
from dotenv import load_dotenv
from tzlocal import get_localzone

load_dotenv()

torch.manual_seed(11)
model_name = "aldsouza/health-agent"
pattern = r'''
    \{                      # Opening brace of the function block
    \s*"name"\s*:\s*"([^"]+)"\s*,      # Capture the function name
    \s*"arguments"\s*:\s*(\{            # Capture the arguments JSON object starting brace
    (?:[^{}]++ | (?2))*?                # Recursive matching for balanced braces (PCRE syntax)
    \})                                # Closing brace of arguments
    \s*\}                             # Closing brace of the function block
    '''

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.float16).to("cuda")
# model_1 = AutoModelForCausalLM.from_pretrained("deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B",torch_dtype=torch.float16).to("cuda")

medical_tools = [
    {
        "name": "symptom_checker",
        "description": "Analyze symptoms and provide possible conditions.",
        "parameters": {
            "symptoms": {
                "description": "List of symptoms reported by the patient.",
                "type": "list[str]",
                "default": ["headache", "fever"]
            }
        }
    },
    {
        "name": "medication_lookup",
        "description": "Look up details about a medication by its name.",
        "parameters": {
            "medication_name": {
                "description": "Name of the medication to look up.",
                "type": "str",
                "default": "Aspirin"
            }
        }
    },
    {
        "name": "book_appointment",
        "description": "Schedule a medical appointment with a doctor.",
        "parameters": {
            "patient_name": {
                "description": "Name of the patient.",
                "type": "str",
                "default": "John Doe"
            },
            "doctor_specialty": {
                "description": "Specialty of the doctor to book.",
                "type": "str",
                "default": "general practitioner"
            },
            "date": {
                "description": "Preferred date of appointment (YYYY-MM-DD).",
                "type": "str",
                "default": "2025-08-20"
            }
        }
    },
    {
        "name": "get_lab_results",
        "description": "Retrieve lab test results for a patient by test ID.",
        "parameters": {
            "patient_id": {
                "description": "Unique patient identifier.",
                "type": "str",
                "default": "123456"
            },
            "test_id": {
                "description": "Lab test identifier.",
                "type": "str",
                "default": "cbc"
            }
        }
    },
    {
        "name": "request_missing_info",
        "description": "Ask the user for missing or incomplete information needed to fulfill their request.",
        "parameters": {
            "missing_fields": {
                "description": "List of missing required fields to be clarified by the user.",
                "type": "list[str]",
                "default": []
            },
            "context": {
                "description": "Optional context or explanation to help the user provide the missing information.",
                "type": "str",
                "default": ""
            }
        }
    },
    {
        "name": "medical_device_info",
        "description": "Retrieve detailed information about a medical device by its name or model number.",
        "parameters": {
            "device_name": {
                "description": "The name or model number of the medical device to look up.",
                "type": "str",
                "default": "Blood Pressure Monitor"
            }
        }
    }, {
        "name": "record_blood_pressure",
        "description": "Record a patient's blood pressure reading with systolic, diastolic, and pulse rate values.",
        "parameters": {
            "patient_id": {
                "description": "Unique identifier of the patient.",
                "type": "str",
                "default": "123456"
            },
            "systolic": {
                "description": "Systolic blood pressure value (mmHg).",
                "type": "int",
                "default": 120
            },
            "diastolic": {
                "description": "Diastolic blood pressure value (mmHg).",
                "type": "int",
                "default": 80
            },
            "pulse_rate": {
                "description": "Pulse rate in beats per minute.",
                "type": "int",
                "default": 70
            },
            "measurement_time": {
                "description": "Timestamp of the measurement (YYYY-MM-DD HH:MM).",
                "type": "str",
                "default": "2025-08-12 09:00"
            }
        }
    }, {
        "name": "start_blood_pressure_test",
        "description": "Initiate a blood pressure measurement test for a patient using a connected device.",
        "parameters": {
            "patient_id": {
                "description": "Unique identifier of the patient.",
                "type": "str",
                "default": "123456"
            },
            "device_id": {
                "description": "Identifier or model of the blood pressure measuring device.",
                "type": "str",
                "default": "BP-Device-001"
            }
        }
    }
]
# Compose the system prompt embedding the tools JSON
system_prompt = f"""
You are an intelligent AI assistant that uses available tools (functions) to help users achieve their medical-related goals. Your job is to understand the user's intent, identify missing information if needed, and then select and call the most appropriate function(s) to solve the task.

# Rules:
- ALWAYS use the tools provided to answer the user's request, unless explicitly told not to.
- Ask clarifying questions ONLY if the user's request is ambiguous or lacks required input parameters.
- If multiple tools are needed, use them in sequence.
- DO NOT make up data or assume values — request any missing input clearly.

# Output Format:
- Respond using a JSON list of function calls in the following format:
  [
    {{
      "name": "function_name",
      "arguments": {{
        "param1": "value1",
        "param2": "value2"
      }}
  ]
- Only include the functions needed to complete the task.
- If no function is needed or the input is unclear, ask a clarifying question instead of guessing.
- Do NOT respond with explanations or natural language outside the JSON block unless explicitly instructed.

Following are the tools provided to you:
{json.dumps(medical_tools, indent=2)}
"""
SCOPES = ['https://www.googleapis.com/auth/calendar']

def symptom_checker(kwargs):
    print(f"Checking diseases for following symptoms on the web:")
    symptoms = kwargs.get("symptoms",[])
    print(symptoms)
    for i, arg in enumerate(symptoms):
        print(f"{i}. {arg}")
    results = TavilySearchResults()
    information = ""
    for result in results.invoke(f"What causes {''.join(symptoms)}"):
        information = information + result["content"] + "\n"
    return {
        "status":200,
        "message":information
    }

def medication_lookup(kwargs):
    medication_name = kwargs.get("medication_name")
    print(f"Looking up the web for information on {medication_name}....")
    results = TavilySearchResults()
    information = ""
    for result in results.invoke(f"What is {medication_name}?"):
        information = information + result["content"] + "\n"
    return {
            "status": 200,
            "message": information
        }


def create_google_calendar_meeting(
        summary: str,
        start_datetime: str,
        end_datetime: str,
        attendees_emails: list,
        timezone: str = 'America/Chicago'
):
    """
    Creates a Google Calendar event.

    Args:
        summary (str): Event title.
        start_datetime (str): Start datetime in ISO format, e.g., "2025-08-18T10:00:00-06:00".
        end_datetime (str): End datetime in ISO format.
        attendees_emails (list): List of attendee emails.
        timezone (str): Timezone string, default 'America/Chicago'.
    """

    creds = None
    # Load saved credentials if available
    if os.path.exists('token.pickle'):
        with open('token.pickle', 'rb') as token:
            creds = pickle.load(token)

    # Authenticate if necessary
    if not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            creds.refresh(Request())
        else:
            flow = InstalledAppFlow.from_client_secrets_file('credentials.json', SCOPES)
            creds = flow.run_local_server(port=0)
        with open('token.pickle', 'wb') as token:
            pickle.dump(creds, token)

    service = build('calendar', 'v3', credentials=creds)

    event = {
        'summary': summary,
        'location': 'Virtual / Google Meet',
        'description': f'{summary} meeting.',
        'start': {'dateTime': start_datetime, 'timeZone': timezone},
        'end': {'dateTime': end_datetime, 'timeZone': timezone},
        'attendees': [{'email': email} for email in attendees_emails],
        'reminders': {'useDefault': True},
    }

    created_event = service.events().insert(
        calendarId='primary', body=event, sendUpdates='all'
    ).execute()

    print(f"Event created: {created_event.get('htmlLink')}")
    return created_event
def book_appointment(kwargs):
    patient_name = kwargs.get("patient_name")
    doctor_specialty = kwargs.get("doctor_specialty")
    date_str = kwargs.get("date")
    parsed_date = datetime.strptime(date_str, "%Y-%m-%d").date()

    # Default time 9:00 AM Mountain Time
    mountain_tz = pytz.timezone("America/Denver")
    dt_mt = datetime.combine(parsed_date, time_1(9, 0))
    dt_mt = mountain_tz.localize(dt_mt)

    # Autodetect local timezone
    local_tz = get_localzone()
    dt_local = dt_mt.astimezone(local_tz)
    dt_local_end = dt_local + timedelta(hours=1)
    result = create_google_calendar_meeting(
        f"Meeting for {patient_name}",
        dt_local.isoformat(),
        dt_local_end.isoformat(),
        ["altondsouza02@gmail.com", "aldsouza@ualberta.ca"]
    )
    return {
        "status":200,
        "message": f"Event Created:{result}"
    }


function_execution_map = {
    "symptom_checker": symptom_checker,
    "medication_lookup": medication_lookup,
    "book_appointment": book_appointment
}


# Example prompt using the medical tools
# messages = [
#     {
#         "content": system_prompt,
#         "role": "system"
#     },
#     {
#         "content": (
#             "I have a headache and mild fever. What could be the possible conditions? "
#             "Also, lookup medication details for 'Ibuprofen'. "
#             "Please book an appointment for patient 'Alice Smith' with a neurologist on 2025-09-01."
#         ),
#         "role": "user"
#     }
# ]

# streamer = TextStreamer(tokenizer, skip_prompt=True)
# streamer = TextIteratorStreamer(tokenizer, skip_prompt=True)
# inputs = tokenizer.apply_chat_template(
#     messages,
#     add_generation_prompt=True,
#     tokenize=True,
#     return_dict=True,
#     return_tensors="pt",
# ).to(model.device)
# inputs = tokenizer.apply_chat_template(
#     messages,
#     add_generation_prompt=True,
#     tokenize=True,
#     return_dict=True,
#     return_tensors="pt",
# ).to(mo)

# generation_kwargs = dict(inputs,streamer=streamer,
#         max_new_tokens=4096,
#         temperature=0.7,)
# thread = Thread(target=model.generate, kwargs=generation_kwargs,daemon=True)
# thread.start()
# for new_text in streamer:
#     print(new_text, end="")
# with torch.no_grad():
#     outputs = model.generate(
#         **inputs,streamer=streamer,
#         max_new_tokens=4096,
#         temperature=0.7,
#     )

class State(TypedDict):
    messages: List[Dict[str, Any]]
    plan: List[Dict[str, Any]]
    task: str


graph_builder = StateGraph(State)

PLANNING_AGENT = "PLANNING_AGENT"


def planning(state: State):
    print("Coming up with Plan")
    messages = state.get("messages", [])
    inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
    ).to(model.device)
    streamer = TextIteratorStreamer(tokenizer, skip_prompt=True)
    generation_kwargs = dict(inputs, streamer=streamer,
                             max_new_tokens=4096,
                             temperature=0.7, )
    thread = Thread(target=model.generate, kwargs=generation_kwargs, daemon=True)
    thread.start()
    generated_text = ""
    for new_text in streamer:
        print(new_text, end="")
        generated_text = generated_text + new_text
    generated_text = generated_text.replace("<｜end▁of▁sentence｜>","").replace("</think>","")

    matches = regex.findall(pattern, generated_text, regex.VERBOSE)
    plan = state.get("plan", [])

    for i, (func_name, args_json) in enumerate(matches, 1):
        plan_entry = dict()
        plan_entry["function_name"] = func_name
        plan_entry["arguments"] = json.loads(args_json)
        plan.append(plan_entry)

    messages.append({"role": "assistant", "content": generated_text})

    return {"messages":messages, "plan": plan}


ROUTER = "ROUTER"


def router(state: State):
    plan = state.get("plan", [])
    if len(plan) > 0:
        return "execute_plan"
    return "respond"


def execute_plan(state: State):
    print("Executing")
    plan = state.get("plan", [])
    for plan_entry in plan:
        plan_entry["status"] = dict()
        print(f"Executing {plan_entry['function_name']} with details {plan_entry['arguments']}")
        print("Approve Execution?(y/n)")
        response = input()
        response = response.strip().lower()

        if response == "y":
            print("Approved.")
            if plan_entry["function_name"] in function_execution_map.keys():
                function = function_execution_map[plan_entry["function_name"]]
                result = function(plan_entry["arguments"])
                plan_entry["status"] = result
            else:
                print(f"Capability not implemented for {plan_entry['function_name']}")
            print("Done with task.")
            print("Proceeding with next.")

        elif response == "n":
            print("Not approved.")
        else:
            print("Invalid input, please enter 'y' or 'n'.")


    return {"plan": plan}


def respond(state: State):
    print(state.get("messages")[-1]["content"])
    return {"plan": state.get("plan")}


def summarize(state: State):
    plan = state.get("plan")
    messages = state.get("messages")
    summary_prompt = []
    summary_prompt.append({
        "role": "user","content": f"Summarize the results obtained from the following tool executions:\n {json.dumps(plan,indent=2)}"
    })
    inputs = tokenizer.apply_chat_template(
        summary_prompt,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
    ).to(model.device)
    streamer = TextIteratorStreamer(tokenizer, skip_prompt=True)
    generation_kwargs = dict(inputs, streamer=streamer,
                             max_new_tokens=4096,
                             temperature=0.7, )
    thread = Thread(target=model.generate, kwargs=generation_kwargs, daemon=True)
    thread.start()
    generated_text = ""
    for new_text in streamer:
        print(new_text, end="")
        generated_text = generated_text + new_text

    messages.append({"role": "assistant", "content": generated_text})

    return {"messages":messages}


EXECUTE_PLAN = "EXECUTE_PLAN"
RESPOND = "RESPOND"
SUMMARIZE = "SUMMARIZE"
graph_builder.add_node(PLANNING_AGENT, planning)
graph_builder.add_node(EXECUTE_PLAN, execute_plan)
graph_builder.add_node(RESPOND, respond)
graph_builder.add_node(SUMMARIZE, summarize)

graph_builder.add_edge(START, PLANNING_AGENT)
graph_builder.add_conditional_edges(PLANNING_AGENT, router, {
    "execute_plan": EXECUTE_PLAN, "respond": RESPOND
})
graph_builder.add_edge(EXECUTE_PLAN, SUMMARIZE)
graph_builder.add_edge(SUMMARIZE, RESPOND)
graph_builder.add_edge(RESPOND, END)
compiled_graph = graph_builder.compile()
png_bytes = compiled_graph.get_graph().draw_mermaid_png()

# Save to file
with open("graph.png", "wb") as f:
    f.write(png_bytes)

print("Graph saved as graph.png")

messages = [
    {
        "content": system_prompt,
        "role": "system"
    },
    {
        "content": (
            "I have a headache and mild fever. What could be the possible conditions? "
            "Also, lookup medication details for 'Ibuprofen'. "
            "Please book an appointment for patient 'Alice Smith' with a neurologist on 2025-08-18."
        ),
        "role": "user"
    }
]
different_user_prompt = [
    {
        "content": system_prompt,
        "role": "system"
    },
    {
        "content": (
            "My mother has chest pain and shortness of breath. "
            "Can you analyze her symptoms? "
            "Also, please look up information about 'Nitroglycerin' medication. "
            "Finally, get lab results for patient ID '987654' for the test 'lipid_panel'."
        ),
        "role": "user"
    }
]
compiled_graph.invoke({"messages": messages})
# compiled_graph.invoke({"messages": different_user_prompt})

Requirements

python

accelerate==1.9.0
aiohappyeyeballs==2.6.1
aiohttp==3.12.15
aiosignal==1.4.0
annotated-types==0.7.0
anyio==4.10.0
attrs==25.3.0
auto_gptq==0.7.1
autolab-core==1.1.1
beautifulsoup4==4.13.4
bitsandbytes==0.46.1
cachetools==5.5.2
certifi==2025.7.14
charset-normalizer==3.4.2
click==8.2.1
colorama==0.4.6
colorlog==6.9.0
contourpy==1.3.3
cycler==0.12.1
dataclasses-json==0.6.7
datasets==4.0.0
dateparser==1.2.2
ddgs==9.5.4
dill==0.3.8
dotenv==0.9.9
duckduckgo_search==8.1.1
duckling==1.8.0
filelock==3.13.1
fonttools==4.59.0
freetype-py==2.5.1
frozenlist==1.7.0
fsspec==2024.6.1
gekko==1.3.0
google-api-core==2.25.1
google-api-python-client==2.179.0
google-auth==2.40.3
google-auth-httplib2==0.2.0
google-auth-oauthlib==1.2.2
googleapis-common-protos==1.70.0
greenlet==3.2.4
h11==0.16.0
hf-xet==1.1.7
httpcore==1.0.9
httplib2==0.22.0
httpx==0.28.1
httpx-sse==0.4.1
huggingface-hub==0.34.3
idna==3.10
imageio==2.37.0
Jinja2==3.1.4
joblib==1.5.1
jpype1==1.6.0
jsonpatch==1.33
jsonpointer==3.0.0
jsonschema==4.25.0
jsonschema-specifications==2025.4.1
kiwisolver==1.4.8
langchain==0.3.27
langchain-community==0.3.27
langchain-core==0.3.74
langchain-huggingface==0.3.1
langchain-text-splitters==0.3.9
langgraph==0.6.5
langgraph-checkpoint==2.1.1
langgraph-prebuilt==0.6.4
langgraph-sdk==0.2.0
langsmith==0.4.14
lazy_loader==0.4
lxml==6.0.0
manifold3d==3.2.1
mapbox_earcut==1.0.3
markdown-it-py==3.0.0
markdownify==1.1.0
MarkupSafe==2.1.5
marshmallow==3.26.1
matplotlib==3.10.5
mdurl==0.1.2
mpmath==1.3.0
multidict==6.6.3
multiprocess==0.70.16
mypy_extensions==1.1.0
networkx==3.3
numpy==2.1.2
oauthlib==3.3.1
opencv-python==4.12.0.88
optimum==1.27.0
orjson==3.11.2
ormsgpack==1.10.0
packaging==25.0
pandas==2.3.1
peft==0.17.0
pillow==11.0.0
primp==0.15.0
propcache==0.3.2
proto-plus==1.26.1
protobuf==6.32.0
psutil==7.0.0
pyarrow==21.0.0
pyasn1==0.6.1
pyasn1_modules==0.4.2
pycollada==0.9.2
pydantic==2.11.7
pydantic-settings==2.10.1
pydantic_core==2.33.2
pyglet==2.1.8
Pygments==2.19.2
PyOpenGL==3.1.0
pyparsing==3.2.3
pyreadline==2.1
pyrender==0.1.45
python-dateutil==2.9.0.post0
python-dotenv==1.1.1
pytz==2025.2
PyYAML==6.0.2
referencing==0.36.2
regex==2025.7.34
requests==2.32.4
requests-oauthlib==2.0.0
requests-toolbelt==1.0.0
rich==14.1.0
rouge==1.0.1
rpds-py==0.27.0
rsa==4.9.1
rtree==1.4.1
ruamel.yaml==0.18.14
ruamel.yaml.clib==0.2.12
safetensors==0.5.3
scikit-image==0.25.2
scikit-learn==1.7.1
scipy==1.16.1
sentencepiece==0.2.1
setproctitle==1.3.6
shapely==2.1.1
six==1.17.0
smolagents==1.20.0
sniffio==1.3.1
soupsieve==2.7
SQLAlchemy==2.0.43
svg.path==7.0
sympy==1.13.3
tenacity==9.1.2
threadpoolctl==3.6.0
tifffile==2025.6.11
tokenizers==0.21.4
torch==2.7.1+cu126
torchaudio==2.7.1+cu126
torchvision==0.22.1+cu126
tqdm==4.67.1
transformers==4.54.1
trimesh==4.7.4
trl==0.20.0
typing-inspect==0.9.0
typing-inspection==0.4.1
typing_extensions==4.14.1
tzdata==2025.2
tzlocal==5.3.1
uritemplate==4.2.0
urllib3==2.5.0
vhacdx==0.0.8.post2
visualization==1.0.0
xxhash==3.5.0
yarl==1.20.1
zstandard==0.24.0

How to Get Started

python

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

import json

torch.manual_seed(42)
model_name = "aldsouza/health-agent"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.float16).to("cuda")

medical_tools = [
        {
            "name": "symptom_checker",
            "description": "Analyze symptoms and provide possible conditions.",
            "parameters": {
                "symptoms": {
                    "description": "List of symptoms reported by the patient.",
                    "type": "list[str]",
                    "default": ["headache", "fever"]
                }
            }
        },
        {
            "name": "medication_lookup",
            "description": "Look up details about a medication by its name.",
            "parameters": {
                "medication_name": {
                    "description": "Name of the medication to look up.",
                    "type": "str",
                    "default": "Aspirin"
                }
            }
        },
        {
            "name": "book_appointment",
            "description": "Schedule a medical appointment with a doctor.",
            "parameters": {
                "patient_name": {
                    "description": "Name of the patient.",
                    "type": "str",
                    "default": "John Doe"
                },
                "doctor_specialty": {
                    "description": "Specialty of the doctor to book.",
                    "type": "str",
                    "default": "general practitioner"
                },
                "date": {
                    "description": "Preferred date of appointment (YYYY-MM-DD).",
                    "type": "str",
                    "default": "2025-08-20"
                }
            }
        },
        {
            "name": "get_lab_results",
            "description": "Retrieve lab test results for a patient by test ID.",
            "parameters": {
                "patient_id": {
                    "description": "Unique patient identifier.",
                    "type": "str",
                    "default": "123456"
                },
                "test_id": {
                    "description": "Lab test identifier.",
                    "type": "str",
                    "default": "cbc"
                }
            }
        },
        {
            "name": "request_missing_info",
            "description": "Ask the user for missing or incomplete information needed to fulfill their request.",
            "parameters": {
                "missing_fields": {
                    "description": "List of missing required fields to be clarified by the user.",
                    "type": "list[str]",
                    "default": []
                },
                "context": {
                    "description": "Optional context or explanation to help the user provide the missing information.",
                    "type": "str",
                    "default": ""
                }
            }
        },
        {
            "name": "medical_device_info",
            "description": "Retrieve detailed information about a medical device by its name or model number.",
            "parameters": {
                "device_name": {
                    "description": "The name or model number of the medical device to look up.",
                    "type": "str",
                    "default": "Blood Pressure Monitor"
                }
            }
        }, {
            "name": "record_blood_pressure",
            "description": "Record a patient's blood pressure reading with systolic, diastolic, and pulse rate values.",
            "parameters": {
                "patient_id": {
                    "description": "Unique identifier of the patient.",
                    "type": "str",
                    "default": "123456"
                },
                "systolic": {
                    "description": "Systolic blood pressure value (mmHg).",
                    "type": "int",
                    "default": 120
                },
                "diastolic": {
                    "description": "Diastolic blood pressure value (mmHg).",
                    "type": "int",
                    "default": 80
                },
                "pulse_rate": {
                    "description": "Pulse rate in beats per minute.",
                    "type": "int",
                    "default": 70
                },
                "measurement_time": {
                    "description": "Timestamp of the measurement (YYYY-MM-DD HH:MM).",
                    "type": "str",
                    "default": "2025-08-12 09:00"
                }
            }
        }, {
            "name": "start_blood_pressure_test",
            "description": "Initiate a blood pressure measurement test for a patient using a connected device.",
            "parameters": {
                "patient_id": {
                    "description": "Unique identifier of the patient.",
                    "type": "str",
                    "default": "123456"
                },
                "device_id": {
                    "description": "Identifier or model of the blood pressure measuring device.",
                    "type": "str",
                    "default": "BP-Device-001"
                }
            }
        }
    ]
    # Compose the system prompt embedding the tools JSON
    system_prompt = f"""
You are an intelligent AI assistant that uses available tools (functions) to help users achieve their medical-related goals. Your job is to understand the user's intent, identify missing information if needed, and then select and call the most appropriate function(s) to solve the task.

# Rules:
- ALWAYS use the tools provided to answer the user's request, unless explicitly told not to.
- Ask clarifying questions ONLY if the user's request is ambiguous or lacks required input parameters.
- If multiple tools are needed, use them in sequence.
- DO NOT make up data or assume values — request any missing input clearly.

# Output Format:
- Respond using a JSON list of function calls in the following format:
  [
    {{
      "name": "function_name",
      "arguments": {{
        "param1": "value1",
        "param2": "value2"
      }}
  ]
- Only include the functions needed to complete the task.
- If no function is needed or the input is unclear, ask a clarifying question instead of guessing.
- Do NOT respond with explanations or natural language outside the JSON block unless explicitly instructed.

Following are the tools provided to you:
{json.dumps(medical_tools, indent=2)}
"""

    # Example prompt using the medical tools
messages = [
        {
            "content": system_prompt,
            "role": "system"
        },
        {
            "content": (
                "I have a headache and mild fever. What could be the possible conditions? "
                "Also, lookup medication details for 'Ibuprofen'. "
                "Please book an appointment for patient 'Alice Smith' with a neurologist on 2025-09-01."
            ),
            "role": "user"
        }
    ]

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
    ).to(model.device)

    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=4096,
            temperature=0.7,
        )

    response = tokenizer.decode(outputs[0])

print(tokenizer.decode(outputs[0], skip_special_tokens=True))