slim api ehr response

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "python.analysis.extraPaths": [
+        "./ai_med_extract/utils"
+    ]
+}

ai_med_extract/api/routes.py

@@ -404,7 +404,8 @@ def register_routes(app, agents):
             if not chartsummarydtl:
                 return jsonify({"error": "Missing chartsummarydtl in input"}), 400
             # Normalize visits
-            visits = parse_ehr_chartsummarydtl(chartsummarydtl)
+            # visits = parse_ehr_chartsummarydtl(chartsummarydtl)
+            visits = chartsummarydtl
             # Extract patient demographics if available
             patient_info = ""
             if isinstance(ehr_result, dict):
@@ -1046,6 +1047,7 @@ def register_routes(app, agents):
         from ai_med_extract.utils.openvino_summarizer_utils import (
             parse_ehr_chartsummarydtl, visits_sorted, compute_deltas, build_compact_baseline, delta_to_text, build_main_prompt
         )
+        from ai_med_extract.utils.json_slimmer import slim_api_json, PruneOptions
         try:
             start_total = time.time()
             data = request.get_json()
@@ -1082,6 +1084,25 @@ def register_routes(app, agents):
             t_api_start = time.time()
             try:
                 response = requests.post(api_url, json={"patientid": patientid}, headers=headers, timeout=EHR_TIMEOUT)
+                # ✅ Slim incoming EHR API response
+                opts = PruneOptions(
+                    remove_nulls=True,
+                    remove_empty_strings=True,
+                    remove_empty_collections=True,
+                    trim_strings=False,       # preserve clinical text
+                    compact_lists=True,
+                    preserve_paths=set(),     # add dot paths here if some fields must always stay
+                    output_minified_string=False,  # dict instead of string
+                )
+                # Log token count before slim_api_json
+                tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased", trust_remote_code=True, cache_dir=os.environ.get('HF_HOME', '/tmp/huggingface'))
+                before_tokens = len(tokenizer.encode(response.text))
+                logger.info(f"Token count before slim_api_json: {before_tokens}")
+                api_data = slim_api_json(response.text, options=opts)
+                # Log token count after slim_api_json
+                after_tokens = len(tokenizer.encode(json.dumps(api_data)))
+                logger.info(f"Token count after slim_api_json: {after_tokens}")
+
             except requests.exceptions.Timeout:
                 logger.warning(f"EHR API timeout ({EHR_TIMEOUT}s) — returning structured fallback.")
                 minimal_fallback = f"""
@@ -1177,9 +1198,10 @@ def register_routes(app, agents):
                     "timing": {"total": round(time.time() - start_total, 1)},
                     "timeout_mode_used": timeout_mode
                 }), 500
-
+               
             # Parse and compute deltas — YOUR LOGIC PRESERVED
-            visits = parse_ehr_chartsummarydtl(chartsummarydtl)
+            # visits = parse_ehr_chartsummarydtl(chartsummarydtl)
+            visits =  chartsummarydtl
             delta = compute_deltas([], visits)
             all_visits = visits_sorted(visits)
             baseline = build_compact_baseline(all_visits)
@@ -1240,7 +1262,7 @@ Generate the full 4-section summary based on the data.</s>
                             full_prompt,
                             max_tokens=1500,  # Increased for fuller section generation
                             temperature=0.0, # Set to 0.0 for maximum determinism and often faster generation.
-                            top_p=1.0,       # Set to 1.0 to consider all tokens, often faster than sampling with top_p < 1.0.
+                            top_p=0.3,       # Set to 1.0 to consider all tokens, often faster than sampling with top_p < 1.0.
                             # top_k=50,        # Adding top_k can sometimes speed up sampling. 50 is a good balance.
                             # repeat_penalty=1.1 # A small penalty can prevent loops and potentially speed up convergence.
                             )

ai_med_extract/utils/json_slimmer.py

@@ -0,0 +1,119 @@
+import json
+import re
+from typing import Any, Dict, List, Set, Union
+
+
+class PruneOptions:
+    def __init__(
+        self,
+        remove_nulls: bool = True,
+        remove_empty_strings: bool = True,
+        remove_empty_collections: bool = True,
+        trim_strings: bool = False,   # ⚠️ Keep False for clinical text
+        compact_lists: bool = True,
+        preserve_paths: Set[str] = None,
+        output_minified_string: bool = True,
+    ):
+        self.remove_nulls = remove_nulls
+        self.remove_empty_strings = remove_empty_strings
+        self.remove_empty_collections = remove_empty_collections
+        self.trim_strings = trim_strings
+        self.compact_lists = compact_lists
+        self.preserve_paths = preserve_paths or set()
+        self.output_minified_string = output_minified_string
+
+
+def _minify_lossless(text: str) -> str:
+    """Drop whitespace outside strings, keep everything inside intact."""
+    out = []
+    in_string = False
+    escaping = False
+    for ch in text:
+        if in_string:
+            out.append(ch)
+            if escaping:
+                escaping = False
+            elif ch == "\\":
+                escaping = True
+            elif ch == '"':
+                in_string = False
+        else:
+            if ch == '"':
+                in_string = True
+                out.append(ch)
+            elif ch in " \t\n\r":
+                continue  # drop whitespace outside strings
+            else:
+                out.append(ch)
+    return "".join(out)
+
+
+def _preserve(path: str, options: PruneOptions) -> bool:
+    return path and path in options.preserve_paths
+
+
+def _prune(value: Any, options: PruneOptions, path: str) -> Any:
+    if _preserve(path, options):
+        return value
+
+    if value is None:
+        return None if options.remove_nulls else value
+
+    if isinstance(value, (bool, int, float)):
+        return value
+
+    if isinstance(value, str):
+        if options.trim_strings:
+            t = value.strip()
+            if options.remove_empty_strings and t == "":
+                return None
+            return t
+        else:
+            if options.remove_empty_strings and value == "":
+                return None
+            return value
+
+    if isinstance(value, list):
+        out = []
+        for i, item in enumerate(value):
+            pruned = _prune(item, options, f"{path}[{i}]")
+            if options.compact_lists:
+                if pruned is None:
+                    continue
+                if isinstance(pruned, (list, dict)) and not pruned and options.remove_empty_collections:
+                    continue
+            out.append(pruned)
+        if options.remove_empty_collections and not out:
+            return None
+        return out
+
+    if isinstance(value, dict):
+        out = {}
+        for k, v in value.items():
+            next_path = f"{path}.{k}" if path else k
+            pruned = _prune(v, options, next_path)
+            if pruned is None and options.remove_nulls:
+                continue
+            if isinstance(pruned, str) and options.remove_empty_strings and pruned == "":
+                continue
+            if isinstance(pruned, (list, dict)) and not pruned and options.remove_empty_collections:
+                continue
+            out[k] = pruned
+        if options.remove_empty_collections and not out:
+            return None
+        return out
+
+    return value
+
+
+def slim_api_json(response_body: str, options: PruneOptions = PruneOptions()) -> Union[str, dict]:
+    # Pure minify if pruning disabled
+    if not any([options.remove_nulls, options.remove_empty_strings,
+                options.remove_empty_collections, options.compact_lists,
+                options.trim_strings]):
+        s = _minify_lossless(response_body)
+        return s if options.output_minified_string else json.loads(s)
+
+    decoded = json.loads(response_body)
+    pruned = _prune(decoded, options, path="")
+    return json.dumps(pruned, separators=(",", ":")) if options.output_minified_string else pruned