Spaces:
Sleeping
Sleeping
| # MAI-DX Orchestrator - Повний керівник користувача | |
| ## 📋 Зміст | |
| - [Огляд системи](#-огляд-системи) | |
| - [Установка та налаштування](#-установка-та-налаштування) | |
| - [Швидкий старт](#-швидкий-старт) | |
| - [Режими роботи](#-режими-роботи) | |
| - [Детальне використання](#-детальне-використання) | |
| - [Приклади використання](#-приклади-використання) | |
| - [Troubleshooting](#-troubleshooting) | |
| - [Production рекомендації](#-production-рекомендації) | |
| - [API Reference](#-api-reference) | |
| --- | |
| ## 🔬 Огляд системи | |
| **MAI-DX (MAI Diagnostic Orchestrator)** - це ШІ-система медичної діагностики, що реалізує дослідження Microsoft Research "Sequential Diagnosis with Language Models". Система імітує консиліум з 8 спеціалізованих лікарів-агентів для проведення поетапної медичної діагностики з оптимізацією економічної ефективності. | |
| ### Наукові результати | |
| **Дослідження на Sequential Diagnosis Benchmark:** | |
| - **304 складних діагностичних випадки** з New England Journal of Medicine (NEJM-CPC) | |
| - **80% точність діагностики** з OpenAI o3 моделлю | |
| - **85.5% точність** у максимальному режимі | |
| - **В 4 рази точніше** за лікарів-загальників (20% базовий показник) | |
| - **20% економія витрат** порівняно з лікарями | |
| - **70% економія витрат** порівняно з прямим використанням LLM | |
| ### Ключові особливості | |
| - 🧠 **8 ШІ-агентів лікарів** з різними спеціалізаціями | |
| - 💰 **Контроль витрат** на 25+ медичних тестів та процедур | |
| - 🎯 **5 режимів роботи** для різних сценаріїв (instant, question_only, budgeted, no_budget, ensemble) | |
| - 🤖 **Підтримка різних LLM** (GPT, Gemini, Claude, Grok, DeepSeek, Llama) | |
| - 📊 **5-бальна система оцінювання** точності діагнозів | |
| - 🔄 **Ітеративний процес** секвенціальної діагностики | |
| - 🏥 **Model-agnostic orchestrator** - працює з будь-якими LLM | |
| ### Архітектура агентів | |
| | Агент | Роль | Функція | | |
| |-------|------|---------| | |
| | 🧠 **Dr. Hypothesis** | Діагност | Формує та оновлює диференційний діагноз | | |
| | 🔬 **Dr. Test-Chooser** | Лабораторний координатор | Обирає найефективніші діагностичні тести | | |
| | 🤔 **Dr. Challenger** | Критик | Запобігає когнітивним упередженням | | |
| | 💰 **Dr. Stewardship** | Економіст | Контролює витрати на обстеження | | |
| | ✅ **Dr. Checklist** | Контролер якості | Перевіряє повноту діагностики | | |
| | 🤝 **Consensus Coordinator** | Модератор | Координує рішення панелі | | |
| | 🔑 **Gatekeeper** | Інформаційний портал | Надає клінічні дані | | |
| | ⚖️ **Judge** | Оцінювач | Оцінює точність фінального діагнозу | | |
| ## 📊 Benchmark Results та Валідація | |
| ### Sequential Diagnosis Benchmark (NEJM-CPC) | |
| **Офіційні результати тестування на 304 складних випадках:** | |
| | Model Combination | Accuracy | Cost Efficiency | Notes | | |
| |-------------------|----------|-----------------|-------| | |
| | MAI-DxO + o3 | **80.0%** | 70% економія vs raw o3 | Найкраща комбінація | | |
| | MAI-DxO + o3 (max mode) | **85.5%** | - | Максимальна точність | | |
| | Generalist physicians | 20.0% | Baseline cost | Контрольна група | | |
| | Raw o3 (no orchestrator) | ~65% | Baseline cost | Без оркестратора | | |
| **Результати по моделях (з MAI-DxO):** | |
| - **OpenAI o3**: 80% точність | |
| - **GPT-4**: ~70% точність | |
| - **Gemini Pro**: ~68% точність | |
| - **Claude**: ~72% точність | |
| - **Grok**: ~65% точність | |
| - **DeepSeek**: ~63% точність | |
| - **Llama**: ~60% точність | |
| ### Економічна ефективність | |
| **Середня вартість діагностики:** | |
| - **Лікарі**: $2,400 (базова лінія) | |
| - **MAI-DxO**: $1,920 (20% економія) | |
| - **Raw LLM**: $6,400 (170% переплата) | |
| **Оптимальні бюджети по режимах:** | |
| - **instant**: $500-800 (60-75% точність) | |
| - **question_only**: $800-1200 (70-85% точність) | |
| - **budgeted**: $1500-3000 (80-90% точність) | |
| - **no_budget**: $3000-8000 (85-95% точність) | |
| - **ensemble**: $5000-15000 (90-98% точність) | |
| ### Передумови | |
| - **Python 3.10+** (рекомендовано 3.11) | |
| - **UV package manager** (або pip) | |
| - **API ключі** для LLM сервісів | |
| ### Крок 1: Установка UV (якщо потрібно) | |
| ```bash | |
| # macOS/Linux | |
| curl -LsSf https://astral.sh/uv/install.sh | sh | |
| # Windows | |
| powershell -c "irm https://astral.sh/uv/install.ps1 | iex" | |
| # Через Homebrew (macOS) | |
| brew install uv | |
| ``` | |
| ### Крок 2: Встановлення MAI-DX | |
| #### Варіант 1: Через pip (рекомендовано) | |
| ```bash | |
| # Встановлення опублікованого пакету | |
| pip install mai-dx python-dotenv | |
| # Перевірка установки | |
| python -c "from mai_dx import MaiDxOrchestrator; print('✅ MAI-DX готовий')" | |
| ``` | |
| #### Варіант 2: Development версія (для розробників) | |
| ```bash | |
| # Клонування репозиторію | |
| git clone https://github.com/The-Swarm-Corporation/Open-MAI-Dx-Orchestrator.git | |
| cd Open-MAI-Dx-Orchestrator | |
| # Встановлення залежностей | |
| pip install -r requirements.txt | |
| # Встановлення в режимі розробки | |
| pip install -e . | |
| ``` | |
| #### Варіант 3: З UV (альтернативний пакетний менеджер) | |
| ```bash | |
| # Якщо використовуєте UV | |
| uv add mai-dx python-dotenv | |
| # Створення UV-сумісного pyproject.toml | |
| uv init --name mai-dx-local --no-readme | |
| uv add mai-dx python-dotenv | |
| uv sync | |
| ``` | |
| ### Крок 3: Налаштування API ключів | |
| ```bash | |
| # Створюємо .env файл | |
| cat > .env << 'EOF' | |
| # API ключі (ОБОВ'ЯЗКОВО) | |
| OPENAI_API_KEY="your-openai-api-key-here" | |
| GEMINI_API_KEY="your-gemini-api-key-here" | |
| ANTHROPIC_API_KEY="your-anthropic-api-key-here" | |
| # Додаткові налаштування | |
| PROJECT_NAME="MAI-Dx-Local" | |
| ENVIRONMENT="development" | |
| DEBUG=true | |
| # Відключення проблемних виводів | |
| SWARMS_VERBOSITY="ERROR" | |
| RICH_TRACEBACK="0" | |
| SWARMS_SHOW_PANEL="false" | |
| EOF | |
| # Захищаємо файл | |
| chmod 600 .env | |
| ``` | |
| ### Крок 4: Перевірка установки | |
| ```bash | |
| # Створюємо тестовий файл | |
| cat > test_setup.py << 'EOF' | |
| import os | |
| from dotenv import load_dotenv | |
| load_dotenv() | |
| def test_installation(): | |
| print("🔧 Тестування установки...") | |
| # Перевірка API ключів | |
| required_keys = ['OPENAI_API_KEY', 'GEMINI_API_KEY', 'ANTHROPIC_API_KEY'] | |
| missing = [k for k in required_keys if not os.getenv(k)] | |
| if missing: | |
| print(f"❌ Відсутні ключі: {', '.join(missing)}") | |
| return False | |
| # Перевірка імпорту | |
| try: | |
| from mai_dx import MaiDxOrchestrator | |
| print("✅ MAI-DX імпортовано успішно") | |
| return True | |
| except ImportError as e: | |
| print(f"❌ Помилка імпорту: {e}") | |
| return False | |
| if __name__ == "__main__": | |
| success = test_installation() | |
| print("🎉 Готово до роботи!" if success else "🔧 Потрібні виправлення") | |
| EOF | |
| # Запускаємо тест | |
| uv run python test_setup.py | |
| ``` | |
| --- | |
| ## 🚀 Швидкий старт | |
| ### Базовий приклад | |
| ```python | |
| import os | |
| from dotenv import load_dotenv | |
| from mai_dx import MaiDxOrchestrator | |
| # Завантажуємо налаштування | |
| load_dotenv() | |
| # Відключаємо verbose вивід | |
| os.environ["SWARMS_VERBOSITY"] = "ERROR" | |
| os.environ["SWARMS_SHOW_PANEL"] = "false" | |
| # Створюємо оркестратор | |
| orchestrator = MaiDxOrchestrator( | |
| model_name="gemini/gemini-2.5-flash", | |
| max_iterations=3, | |
| initial_budget=1000, | |
| mode="question_only" | |
| ) | |
| # Медичний випадок | |
| case_info = """ | |
| 25-year-old male with severe headache for 2 days. | |
| Pain is bilateral, throbbing, 8/10 intensity. | |
| Photophobia and nausea present. | |
| No fever or neck stiffness. | |
| """ | |
| # Запускаємо діагностику | |
| result = orchestrator.run( | |
| initial_case_info=case_info, | |
| full_case_details=case_info, | |
| ground_truth_diagnosis="Migraine" | |
| ) | |
| # Результат | |
| print(f"Діагноз: {result.final_diagnosis}") | |
| print(f"Точність: {result.accuracy_score}/5.0") | |
| print(f"Вартість: ${result.total_cost}") | |
| ``` | |
| ### Швидкий діагностичний скрипт | |
| ```python | |
| #!/usr/bin/env python3 | |
| """ | |
| Швидкий діагностичний інструмент | |
| Використання: python quick_diagnose.py "медичний випадок" | |
| """ | |
| import sys | |
| import os | |
| from dotenv import load_dotenv | |
| from mai_dx import MaiDxOrchestrator | |
| def quick_diagnose(case_description, mode="question_only"): | |
| """Швидка діагностика медичного випадку""" | |
| # Налаштування | |
| load_dotenv() | |
| os.environ["SWARMS_VERBOSITY"] = "ERROR" | |
| # Створення оркестратора | |
| orchestrator = MaiDxOrchestrator( | |
| model_name="gemini/gemini-2.5-flash", | |
| max_iterations=3, | |
| initial_budget=1500, | |
| mode=mode | |
| ) | |
| print("🩺 MAI-DX діагностика...") | |
| print("⏳ Аналіз випадку...") | |
| try: | |
| result = orchestrator.run( | |
| initial_case_info=case_description, | |
| full_case_details=case_description, | |
| ground_truth_diagnosis="Unknown" | |
| ) | |
| print(f"\n🎯 Діагноз: {result.final_diagnosis}") | |
| print(f"⭐ Впевненість: {result.accuracy_score}/5.0") | |
| print(f"💰 Вартість: ${result.total_cost}") | |
| print(f"🔄 Ітерації: {result.iterations}") | |
| return result.final_diagnosis | |
| except Exception as e: | |
| print(f"❌ Помилка: {e}") | |
| return None | |
| if __name__ == "__main__": | |
| if len(sys.argv) > 1: | |
| case = " ".join(sys.argv[1:]) | |
| quick_diagnose(case) | |
| else: | |
| print("Використання: python quick_diagnose.py 'медичний випадок'") | |
| ``` | |
| --- | |
| ## 🎛️ Режими роботи | |
| ### 1. **instant** - Миттєвий режим | |
| **Призначення:** Найшвидший режим для термінових консультацій | |
| ```python | |
| orchestrator = MaiDxOrchestrator( | |
| mode="instant", | |
| initial_budget=800, # Мінімальний бюджет | |
| max_iterations=2 # Дуже швидкі ітерації | |
| ) | |
| ``` | |
| **Характеристики:** | |
| - ⚡ Швидкість: 30-90 секунд | |
| - 💰 Вартість: $200-600 | |
| - 🎯 Точність: 60-75% | |
| - 📝 Методи: Швидкий аналіз без складних тестів | |
| **Ідеально для:** | |
| - Невідкладних ситуацій | |
| - Первинного скринінгу | |
| - Швидких консультацій | |
| ### 2. **question_only** - Тільки питання | |
| **Призначення:** Швидкі консультації без дорогих тестів | |
| ```python | |
| orchestrator = MaiDxOrchestrator( | |
| mode="question_only", | |
| initial_budget=1000, # Мінімальний бюджет | |
| max_iterations=3 # Швидкі ітерації | |
| ) | |
| ``` | |
| **Характеристики:** | |
| - ⚡ Швидкість: 1-3 хвилини | |
| - 💰 Вартість: $300-800 | |
| - 🎯 Точність: 70-85% | |
| - 📝 Методи: Тільки клінічні питання | |
| **Ідеально для:** | |
| - Первинних консультацій | |
| - Швидких оцінок | |
| - Освітніх цілей | |
| ### 3. **budgeted** - З бюджетними обмеженнями | |
| **Призначення:** Збалансований підхід з контролем витрат | |
| ```python | |
| orchestrator = MaiDxOrchestrator( | |
| mode="budgeted", | |
| initial_budget=3000, # Середній бюджет | |
| max_iterations=5 # Збалансовані ітерації | |
| ) | |
| ``` | |
| **Характеристики:** | |
| - ⚡ Швидкість: 3-7 хвилин | |
| - 💰 Вартість: $800-3000 | |
| - 🎯 Точність: 80-90% | |
| - 📝 Методи: Питання + обрані тести | |
| **Ідеально для:** | |
| - Рутинної діагностики | |
| - Амбулаторних випадків | |
| - Економічно ефективної медицини | |
| ### 4. **no_budget** - Без обмежень бюджету | |
| **Призначення:** Повна діагностика без фінансових обмежень | |
| ```python | |
| orchestrator = MaiDxOrchestrator( | |
| mode="no_budget", | |
| initial_budget=10000, # Великий бюджет | |
| max_iterations=7 # Повний аналіз | |
| ) | |
| ``` | |
| **Характеристики:** | |
| - ⚡ Швидкість: 5-15 хвилин | |
| - 💰 Вартість: $1000-8000 | |
| - 🎯 Точність: 85-95% | |
| - 📝 Методи: Усі доступні тести та процедури | |
| **Ідеально для:** | |
| - Складних випадків | |
| - Рідкісних захворювань | |
| - Критичних ситуацій | |
| ### 5. **ensemble** - Консенсус кількох запусків | |
| **Призначення:** Максимальна точність через множинні аналізи | |
| ```python | |
| orchestrator = MaiDxOrchestrator( | |
| mode="budgeted", # Базовий режим для кожного запуску | |
| max_iterations=3 | |
| ) | |
| # Запуск ensemble | |
| result = orchestrator.run_ensemble( | |
| initial_case_info=case, | |
| full_case_details=case, | |
| ground_truth_diagnosis=truth, | |
| num_runs=3 # Кількість незалежних запусків | |
| ) | |
| ``` | |
| **Характеристики:** | |
| - ⚡ Швидкість: 10-30 хвилин | |
| - 💰 Вартість: $2000-15000 | |
| - 🎯 Точність: 90-98% | |
| - 📝 Методи: Консенсус кількох діагностичних сесій | |
| **Результати з наукової роботи Microsoft Research:** | |
| - **80% точність** з OpenAI o3 моделлю | |
| - **85.5% точність** у максимальному режимі | |
| - **В 4 рази точніше** за лікарів-загальників (20% базовий показник) | |
| - **20% економія витрат** порівняно з лікарями | |
| - **70% економія витрат** порівняно з прямим використанням o3 | |
| --- | |
| ## 🔧 Детальне використання | |
| ### Створення оркестратора з повним контролем | |
| ```python | |
| from mai_dx import MaiDxOrchestrator | |
| # Повна конфігурація | |
| orchestrator = MaiDxOrchestrator( | |
| model_name="gemini/gemini-2.5-flash", # Модель LLM | |
| max_iterations=5, # Максимум ітерацій | |
| initial_budget=3000, # Початковий бюджет ($) | |
| mode="budgeted", # Режим роботи | |
| verbose=False # Детальний вивід | |
| ) | |
| # Перевірка налаштувань | |
| print(f"Модель: {orchestrator.model_name}") | |
| print(f"Бюджет: ${orchestrator.initial_budget}") | |
| print(f"Режим: {orchestrator.mode}") | |
| ``` | |
| ### Структура медичного випадку | |
| ```python | |
| # Мінімальна інформація | |
| simple_case = "35-year-old man with chest pain for 2 hours" | |
| # Детальний випадок | |
| detailed_case = """ | |
| Patient: 35-year-old male, construction worker | |
| Chief Complaint: Severe chest pain for 2 hours | |
| History of Present Illness: | |
| - Sudden onset of crushing chest pain during physical work | |
| - Pain radiates to left arm and jaw | |
| - Associated with shortness of breath and sweating | |
| - No relief with rest | |
| Past Medical History: | |
| - Hypertension (controlled with medication) | |
| - Smoking 1 pack/day for 15 years | |
| - Family history of heart disease (father had MI at 50) | |
| Physical Examination: | |
| - Vital signs: BP 150/95, HR 110, RR 22, Temp 98.6°F | |
| - Cardiovascular: Tachycardic, no murmurs | |
| - Respiratory: Clear bilaterally | |
| - Extremities: No edema | |
| Initial Assessment: | |
| - High suspicion for acute coronary syndrome | |
| - Requires immediate evaluation | |
| """ | |
| # Ground truth для оцінювання (опціонально) | |
| expected_diagnosis = "ST-elevation myocardial infarction (STEMI)" | |
| ``` | |
| ### Запуск діагностики з обробкою помилок | |
| ```python | |
| import time | |
| from contextlib import contextmanager | |
| @contextmanager | |
| def diagnostic_session(orchestrator): | |
| """Контекстний менеджер для діагностичної сесії""" | |
| print("🩺 Початок діагностичної сесії...") | |
| start_time = time.time() | |
| try: | |
| yield orchestrator | |
| except KeyboardInterrupt: | |
| print("\n⏹️ Діагностика перервана користувачем") | |
| raise | |
| except Exception as e: | |
| print(f"\n❌ Помилка діагностики: {e}") | |
| raise | |
| finally: | |
| duration = time.time() - start_time | |
| print(f"⏱️ Тривалість сесії: {duration:.1f} секунд") | |
| # Використання | |
| with diagnostic_session(orchestrator) as dx: | |
| result = dx.run( | |
| initial_case_info=case_description, | |
| full_case_details=detailed_case, | |
| ground_truth_diagnosis=expected_diagnosis | |
| ) | |
| # Обробка результату | |
| print(f"\n📋 РЕЗУЛЬТАТИ ДІАГНОСТИКИ") | |
| print(f"🎯 Діагноз: {result.final_diagnosis}") | |
| print(f"🏆 Еталон: {result.ground_truth}") | |
| print(f"⭐ Точність: {result.accuracy_score}/5.0") | |
| print(f"💰 Загальна вартість: ${result.total_cost:,}") | |
| print(f"🔄 Ітерації: {result.iterations}") | |
| # Детальний аналіз | |
| if hasattr(result, 'accuracy_reasoning'): | |
| print(f"💭 Обґрунтування: {result.accuracy_reasoning[:200]}...") | |
| ``` | |
| ### Пакетна обробка випадків | |
| ```python | |
| def batch_diagnose(cases, mode="question_only"): | |
| """Діагностика кількох випадків підряд""" | |
| results = [] | |
| for i, case_data in enumerate(cases, 1): | |
| print(f"\n📋 Випадок {i}/{len(cases)}: {case_data.get('name', f'Case {i}')}") | |
| # Створюємо новий оркестратор для кожного випадку | |
| orchestrator = MaiDxOrchestrator( | |
| model_name="gemini/gemini-2.5-flash", | |
| mode=mode, | |
| initial_budget=2000, | |
| max_iterations=4 | |
| ) | |
| try: | |
| result = orchestrator.run( | |
| initial_case_info=case_data["description"], | |
| full_case_details=case_data.get("details", case_data["description"]), | |
| ground_truth_diagnosis=case_data.get("expected", "Unknown") | |
| ) | |
| # Зберігаємо результат | |
| case_result = { | |
| "case_id": i, | |
| "name": case_data.get("name", f"Case {i}"), | |
| "diagnosis": result.final_diagnosis, | |
| "accuracy": result.accuracy_score, | |
| "cost": result.total_cost, | |
| "iterations": result.iterations, | |
| "success": True | |
| } | |
| results.append(case_result) | |
| print(f"✅ Завершено: {result.final_diagnosis}") | |
| except Exception as e: | |
| print(f"❌ Помилка: {e}") | |
| results.append({ | |
| "case_id": i, | |
| "name": case_data.get("name", f"Case {i}"), | |
| "error": str(e), | |
| "success": False | |
| }) | |
| return results | |
| # Приклад використання | |
| test_cases = [ | |
| { | |
| "name": "Гострий інфаркт", | |
| "description": "55-year-old man with crushing chest pain, sweating, nausea", | |
| "expected": "Myocardial infarction" | |
| }, | |
| { | |
| "name": "Менінгіт", | |
| "description": "20-year-old with severe headache, neck stiffness, fever", | |
| "expected": "Meningitis" | |
| } | |
| ] | |
| results = batch_diagnose(test_cases) | |
| # Аналіз результатів | |
| successful = [r for r in results if r.get("success", False)] | |
| print(f"\n📊 Успішно: {len(successful)}/{len(results)}") | |
| for result in successful: | |
| print(f" {result['name']}: {result['diagnosis']} (Score: {result['accuracy']}/5)") | |
| ``` | |
| --- | |
| ## 💡 Приклади використання | |
| ### 1. Кардіологічний випадок | |
| ```python | |
| # Випадок гострого коронарного синдрому | |
| cardiac_case = """ | |
| Patient: 58-year-old male executive | |
| Chief Complaint: "Crushing chest pain like an elephant sitting on my chest" | |
| History: | |
| - Pain started 3 hours ago while climbing stairs | |
| - Severe, substernal, radiating to left arm and jaw | |
| - Associated with diaphoresis, nausea, shortness of breath | |
| - No relief with rest or antacids | |
| Risk Factors: | |
| - Diabetes mellitus type 2 | |
| - Hypertension | |
| - Hyperlipidemia | |
| - Smoking 2 packs/day for 30 years | |
| - Family history: father died of MI at 52 | |
| Physical Exam: | |
| - Appears uncomfortable, diaphoretic | |
| - Vital signs: BP 180/110, HR 105, RR 24 | |
| - Heart: S4 gallop, no murmurs | |
| - Lungs: Clear bilaterally | |
| - Extremities: No edema | |
| ECG: ST-elevations in leads II, III, aVF | |
| Troponin I: 8.5 ng/mL (normal <0.04) | |
| """ | |
| orchestrator = MaiDxOrchestrator( | |
| mode="no_budget", # Повна діагностика для критичного випадку | |
| initial_budget=5000, | |
| max_iterations=6 | |
| ) | |
| result = orchestrator.run( | |
| initial_case_info=cardiac_case, | |
| full_case_details=cardiac_case, | |
| ground_truth_diagnosis="Inferior STEMI" | |
| ) | |
| print(f"Діагноз: {result.final_diagnosis}") | |
| # Очікуваний результат: "Acute ST-elevation myocardial infarction (STEMI)" | |
| ``` | |
| ### 2. Неврологічний випадок | |
| ```python | |
| # Випадок інсульту | |
| neuro_case = """ | |
| Patient: 67-year-old female with sudden onset neurological symptoms | |
| Presentation: | |
| - Sudden onset of right-sided weakness 2 hours ago | |
| - Difficulty speaking (slurred speech) | |
| - Facial drooping on right side | |
| - No loss of consciousness | |
| History: | |
| - Atrial fibrillation (not on anticoagulation) | |
| - Hypertension | |
| - Previous TIA 6 months ago | |
| Examination: | |
| - Alert but confused | |
| - Right facial droop | |
| - Right arm drift | |
| - Dysarthria | |
| - NIHSS score: 8 | |
| CT Head: No acute hemorrhage | |
| Time from onset: 2 hours 15 minutes | |
| """ | |
| # Використовуємо швидкий режим для невідкладних випадків | |
| orchestrator = MaiDxOrchestrator( | |
| mode="question_only", | |
| max_iterations=2, # Швидко для невідкладної допомоги | |
| initial_budget=800 | |
| ) | |
| result = orchestrator.run( | |
| initial_case_info=neuro_case, | |
| full_case_details=neuro_case, | |
| ground_truth_diagnosis="Acute ischemic stroke" | |
| ) | |
| ``` | |
| ### 3. Педіатричний випадок | |
| ```python | |
| # Дитячий випадок з лихоманкою | |
| pediatric_case = """ | |
| Patient: 3-year-old boy brought by parents for fever and irritability | |
| History: | |
| - Fever up to 39.5°C for 2 days | |
| - Decreased appetite and activity | |
| - Pulling at right ear | |
| - Crying more than usual, especially when lying down | |
| - No cough, runny nose, or vomiting | |
| Past Medical History: | |
| - Full-term delivery, normal development | |
| - Up to date on vaccinations | |
| - No known allergies | |
| Physical Examination: | |
| - Temperature: 39.2°C, HR: 130, RR: 28 | |
| - Generally irritable but consolable | |
| - HEENT: Right tympanic membrane erythematous and bulging | |
| - Neck: Supple, no lymphadenopathy | |
| - Chest: Clear bilaterally | |
| - Abdomen: Soft, non-tender | |
| Assessment needed for appropriate treatment | |
| """ | |
| # Для педіатричних випадків використовуємо обережний підхід | |
| orchestrator = MaiDxOrchestrator( | |
| mode="budgeted", | |
| initial_budget=1500, | |
| max_iterations=4 | |
| ) | |
| result = orchestrator.run( | |
| initial_case_info=pediatric_case, | |
| full_case_details=pediatric_case, | |
| ground_truth_diagnosis="Acute otitis media" | |
| ) | |
| ``` | |
| ### 4. Складний диференційний діагноз | |
| ```python | |
| # Випадок з широким диференційним діагнозом | |
| complex_case = """ | |
| Patient: 45-year-old female with progressive fatigue and weight loss | |
| Chief Complaint: "I'm exhausted all the time and losing weight despite eating" | |
| History of Present Illness: | |
| - 6-month history of progressive fatigue | |
| - Unintentional 15-pound weight loss | |
| - Heat intolerance and excessive sweating | |
| - Palpitations and anxiety | |
| - Difficulty sleeping | |
| - Tremor in hands | |
| Review of Systems: | |
| - Frequent bowel movements (3-4 times daily) | |
| - Hair thinning | |
| - Menstrual irregularities | |
| - No fever, night sweats, or lymph node swelling | |
| Physical Examination: | |
| - Vital signs: BP 150/85, HR 110, RR 16, Temp 98.8°F | |
| - General: Thin, anxious-appearing female | |
| - Eyes: Mild exophthalmos, lid lag | |
| - Thyroid: Diffusely enlarged, no nodules | |
| - Cardiovascular: Tachycardic, no murmurs | |
| - Neurologic: Fine tremor of outstretched hands | |
| - Skin: Warm and moist | |
| This case requires careful consideration of multiple differential diagnoses | |
| """ | |
| # Для складних випадків використовуємо ensemble підхід | |
| orchestrator = MaiDxOrchestrator( | |
| mode="budgeted", | |
| initial_budget=3000, | |
| max_iterations=5 | |
| ) | |
| # Запускаємо кілька незалежних аналізів | |
| ensemble_result = orchestrator.run_ensemble( | |
| initial_case_info=complex_case, | |
| full_case_details=complex_case, | |
| ground_truth_diagnosis="Graves' disease (hyperthyroidism)", | |
| num_runs=2 | |
| ) | |
| print(f"Ensemble діагноз: {ensemble_result.final_diagnosis}") | |
| print(f"Consensus score: {ensemble_result.accuracy_score}/5.0") | |
| ``` | |
| --- | |
| ## 🔧 Troubleshooting | |
| ### Часті проблеми та рішення | |
| #### 1. Rich Console помилки | |
| **Проблема:** | |
| ``` | |
| rich.errors.NotRenderableError: Unable to render None | |
| ``` | |
| **Рішення:** | |
| ```python | |
| import os | |
| # Додайте на початок скрипта | |
| os.environ["SWARMS_VERBOSITY"] = "ERROR" | |
| os.environ["RICH_TRACEBACK"] = "0" | |
| os.environ["SWARMS_SHOW_PANEL"] = "false" | |
| # Патч для Rich formatter | |
| def patch_rich_formatter(): | |
| try: | |
| import swarms.utils.formatter | |
| def dummy_print_panel(*args, **kwargs): | |
| pass | |
| if hasattr(swarms.utils.formatter, 'Formatter'): | |
| swarms.utils.formatter.Formatter._print_panel = dummy_print_panel | |
| return True | |
| except: | |
| return False | |
| patch_rich_formatter() | |
| ``` | |
| #### 2. Function Call помилки | |
| **Проблема:** | |
| ``` | |
| Could not extract function call output from response type: <class 'str'> | |
| ``` | |
| **Рішення:** | |
| - Це внутрішня проблема Swarms framework | |
| - НЕ блокує діагностику | |
| - Система продовжує працювати з fallback механізмами | |
| - Можна ігнорувати ці попередження | |
| #### 3. Проблеми з бюджетом | |
| **Проблема:** | |
| ``` | |
| Remaining budget: $-100 | |
| ``` | |
| **Рішення:** | |
| ```python | |
| # Використовуйте достатні бюджети для кожного режиму | |
| budget_recommendations = { | |
| "question_only": 1000, # Мінімум $800 | |
| "budgeted": 3000, # Мінімум $2000 | |
| "no_budget": 10000 # Мінімум $5000 | |
| } | |
| orchestrator = MaiDxOrchestrator( | |
| mode="budgeted", | |
| initial_budget=budget_recommendations["budgeted"] | |
| ) | |
| ``` | |
| #### 4. API помилки | |
| **Проблема:** | |
| ``` | |
| API key not found or invalid | |
| ``` | |
| **Рішення:** | |
| ```bash | |
| # Перевірте .env файл | |
| cat .env | grep API_KEY | |
| # Перевірте права доступу | |
| ls -la .env | |
| # Переконайтесь що файл завантажується | |
| python -c "from dotenv import load_dotenv; load_dotenv(); import os; print(os.getenv('GEMINI_API_KEY')[:10] if os.getenv('GEMINI_API_KEY') else 'NOT FOUND')" | |
| ``` | |
| #### 5. Повільна робота | |
| **Рішення:** | |
| ```python | |
| # Оптимізовані налаштування для швидкості | |
| fast_orchestrator = MaiDxOrchestrator( | |
| model_name="gemini/gemini-2.5-flash", # Швидша модель | |
| max_iterations=2, # Менше ітерацій | |
| initial_budget=1000, # Менший бюджет | |
| mode="question_only" # Найшвидший режим | |
| ) | |
| ``` | |
| #### 6. Низька точність діагнозів | |
| **Рішення:** | |
| ```python | |
| # Поліпшення точності | |
| precise_orchestrator = MaiDxOrchestrator( | |
| model_name="gpt-4", # Потужніша модель | |
| max_iterations=7, # Більше ітерацій | |
| initial_budget=5000, # Більший бюджет | |
| mode="no_budget" # Повний аналіз | |
| ) | |
| # Або використовуйте ensemble | |
| ensemble_result = orchestrator.run_ensemble( | |
| num_runs=3 # Кілька незалежних запусків | |
| ) | |
| ``` | |
| ### Діагностичні утиліти | |
| ```python | |
| def diagnose_mai_dx_issues(): | |
| """Діагностика проблем MAI-DX""" | |
| print("🔧 Діагностика MAI-DX системи...") | |
| # Перевірка 1: Python версія | |
| import sys | |
| python_version = sys.version_info | |
| if python_version >= (3, 10): | |
| print("✅ Python версія підходить") | |
| else: | |
| print(f"❌ Python {python_version} застара, потрібен 3.10+") | |
| # Перевірка 2: Залежності | |
| try: | |
| import mai_dx, swarms, pydantic, loguru | |
| print("✅ Основні залежності встановлені") | |
| except ImportError as e: | |
| print(f"❌ Відсутня залежність: {e}") | |
| # Перевірка 3: API ключі | |
| from dotenv import load_dotenv | |
| load_dotenv() | |
| api_keys = ["OPENAI_API_KEY", "GEMINI_API_KEY", "ANTHROPIC_API_KEY"] | |
| for key in api_keys: | |
| value = os.getenv(key) | |
| if value: | |
| print(f"✅ {key}: {'*' * (len(value) - 4) + value[-4:]}") | |
| else: | |
| print(f"❌ {key}: не знайдено") | |
| # Перевірка 4: Створення оркестратора | |
| try: | |
| from mai_dx import MaiDxOrchestrator | |
| test_orchestrator = MaiDxOrchestrator( | |
| mode="question_only", | |
| initial_budget=500, | |
| max_iterations=1 | |
| ) | |
| print("✅ Оркестратор створюється без помилок") | |
| except Exception as e: | |
| print(f"❌ Помилка створення оркестратора: {e}") | |
| print("🔧 Діагностика завершена") | |
| # Запуск діагностики | |
| diagnose_mai_dx_issues() | |
| ``` | |
| --- | |
| ## 🚀 Production рекомендації | |
| ### Архітектура для Production | |
| ```python | |
| import logging | |
| import asyncio | |
| from typing import Dict, List, Optional | |
| from dataclasses import dataclass | |
| from datetime import datetime | |
| @dataclass | |
| class DiagnosisRequest: | |
| """Структура запиту на діагностику""" | |
| case_id: str | |
| patient_info: str | |
| clinical_details: str | |
| urgency_level: str = "routine" # routine, urgent, emergency | |
| requested_mode: str = "budgeted" | |
| max_budget: int = 3000 | |
| @dataclass | |
| class DiagnosisResponse: | |
| """Структура відповіді діагностики""" | |
| case_id: str | |
| diagnosis: str | |
| confidence_score: float | |
| cost: float | |
| duration_seconds: float | |
| timestamp: datetime | |
| recommendations: List[str] | |
| status: str # success, partial, failed | |
| class ProductionMAIDX: | |
| """Production-ready MAI-DX wrapper""" | |
| def __init__(self, config: Dict): | |
| self.config = config | |
| self.logger = self._setup_logging() | |
| def _setup_logging(self): | |
| """Налаштування логування для production""" | |
| logging.basicConfig( | |
| level=logging.INFO, | |
| format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', | |
| handlers=[ | |
| logging.FileHandler('mai_dx_production.log'), | |
| logging.StreamHandler() | |
| ] | |
| ) | |
| return logging.getLogger('MAI-DX-Production') | |
| async def diagnose_async(self, request: DiagnosisRequest) -> DiagnosisResponse: | |
| """Асинхронна діагностика для high-throughput""" | |
| start_time = time.time() | |
| self.logger.info(f"Starting diagnosis for case {request.case_id}") | |
| try: | |
| # Створення оркестратора з налаштуваннями | |
| orchestrator = MaiDxOrchestrator( | |
| model_name=self.config.get("model", "gemini/gemini-2.5-flash"), | |
| mode=request.requested_mode, | |
| initial_budget=request.max_budget, | |
| max_iterations=self._get_iterations_for_urgency(request.urgency_level) | |
| ) | |
| # Запуск діагностики | |
| result = orchestrator.run( | |
| initial_case_info=request.patient_info, | |
| full_case_details=request.clinical_details, | |
| ground_truth_diagnosis="Unknown" | |
| ) | |
| duration = time.time() - start_time | |
| # Формування відповіді | |
| response = DiagnosisResponse( | |
| case_id=request.case_id, | |
| diagnosis=result.final_diagnosis, | |
| confidence_score=result.accuracy_score, | |
| cost=result.total_cost, | |
| duration_seconds=duration, | |
| timestamp=datetime.now(), | |
| recommendations=self._extract_recommendations(result), | |
| status="success" | |
| ) | |
| self.logger.info(f"Diagnosis completed for case {request.case_id} in {duration:.2f}s") | |
| return response | |
| except Exception as e: | |
| self.logger.error(f"Diagnosis failed for case {request.case_id}: {e}") | |
| return DiagnosisResponse( | |
| case_id=request.case_id, | |
| diagnosis="Diagnosis failed", | |
| confidence_score=0.0, | |
| cost=0.0, | |
| duration_seconds=time.time() - start_time, | |
| timestamp=datetime.now(), | |
| recommendations=[], | |
| status="failed" | |
| ) | |
| def _get_iterations_for_urgency(self, urgency: str) -> int: | |
| """Налаштування ітерацій залежно від терміновості""" | |
| urgency_configs = { | |
| "emergency": 2, # Швидко для невідкладних випадків | |
| "urgent": 3, # Збалансовано | |
| "routine": 5 # Повний аналіз | |
| } | |
| return urgency_configs.get(urgency, 3) | |
| def _extract_recommendations(self, result) -> List[str]: | |
| """Витяг рекомендацій з результату""" | |
| recommendations = [] | |
| # Базові рекомендації залежно від типу діагнозу | |
| diagnosis = result.final_diagnosis.lower() | |
| if "emergency" in diagnosis or "acute" in diagnosis: | |
| recommendations.append("Immediate medical attention required") | |
| elif "infection" in diagnosis: | |
| recommendations.append("Consider antibiotic therapy") | |
| recommendations.append("Monitor vital signs") | |
| elif "chronic" in diagnosis: | |
| recommendations.append("Long-term management plan needed") | |
| recommendations.append("Regular follow-up recommended") | |
| return recommendations | |
| # Конфігурація для різних середовищ | |
| PRODUCTION_CONFIG = { | |
| "model": "gpt-4", # Найточніша модель для production | |
| "fallback_model": "gemini/gemini-2.5-flash", | |
| "max_concurrent_diagnoses": 5, | |
| "timeout_seconds": 600, | |
| "retry_attempts": 3 | |
| } | |
| DEVELOPMENT_CONFIG = { | |
| "model": "gemini/gemini-2.5-flash", | |
| "max_concurrent_diagnoses": 2, | |
| "timeout_seconds": 300, | |
| "retry_attempts": 1 | |
| } | |
| ``` | |
| ### Monitoring та Metrics | |
| ```python | |
| import time | |
| from collections import defaultdict | |
| from typing import Dict, Any | |
| class MAIDXMetrics: | |
| """Система метрик для моніторингу MAI-DX""" | |
| def __init__(self): | |
| self.metrics = defaultdict(list) | |
| self.counters = defaultdict(int) | |
| def record_diagnosis(self, result: DiagnosisResponse): | |
| """Запис метрик діагностики""" | |
| # Основні метрики | |
| self.metrics["diagnosis_duration"].append(result.duration_seconds) | |
| self.metrics["diagnosis_cost"].append(result.cost) | |
| self.metrics["confidence_score"].append(result.confidence_score) | |
| # Лічильники | |
| self.counters[f"status_{result.status}"] += 1 | |
| self.counters["total_diagnoses"] += 1 | |
| # Метрики якості | |
| if result.confidence_score >= 4.0: | |
| self.counters["high_confidence"] += 1 | |
| elif result.confidence_score >= 2.0: | |
| self.counters["medium_confidence"] += 1 | |
| else: | |
| self.counters["low_confidence"] += 1 | |
| def get_summary(self) -> Dict[str, Any]: | |
| """Отримання зводки метрик""" | |
| if not self.metrics["diagnosis_duration"]: | |
| return {"message": "No diagnoses recorded yet"} | |
| durations = self.metrics["diagnosis_duration"] | |
| costs = self.metrics["diagnosis_cost"] | |
| scores = self.metrics["confidence_score"] | |
| return { | |
| "total_diagnoses": self.counters["total_diagnoses"], | |
| "success_rate": self.counters.get("status_success", 0) / self.counters["total_diagnoses"], | |
| "average_duration": sum(durations) / len(durations), | |
| "average_cost": sum(costs) / len(costs), | |
| "average_confidence": sum(scores) / len(scores), | |
| "high_confidence_rate": self.counters.get("high_confidence", 0) / self.counters["total_diagnoses"], | |
| "performance": { | |
| "min_duration": min(durations), | |
| "max_duration": max(durations), | |
| "min_cost": min(costs), | |
| "max_cost": max(costs) | |
| } | |
| } | |
| def export_metrics(self, filename: str = None): | |
| """Експорт метрик у файл""" | |
| import json | |
| summary = self.get_summary() | |
| if filename: | |
| with open(filename, 'w') as f: | |
| json.dump(summary, f, indent=2, default=str) | |
| return summary | |
| # Використання metrics | |
| metrics = MAIDXMetrics() | |
| # Після кожної діагностики | |
| # metrics.record_diagnosis(diagnosis_response) | |
| # Періодичний звіт | |
| # weekly_report = metrics.get_summary() | |
| # metrics.export_metrics("mai_dx_weekly_report.json") | |
| ``` | |
| ### Безпека та конфіденційність | |
| ```python | |
| import hashlib | |
| import base64 | |
| from cryptography.fernet import Fernet | |
| class MAIDXSecurity: | |
| """Система безпеки для MAI-DX""" | |
| def __init__(self, encryption_key: bytes = None): | |
| if encryption_key: | |
| self.cipher_suite = Fernet(encryption_key) | |
| else: | |
| # Генерація нового ключа (зберігайте безпечно!) | |
| self.cipher_suite = Fernet(Fernet.generate_key()) | |
| def anonymize_patient_data(self, patient_info: str) -> tuple: | |
| """Анонімізація пацієнтських даних""" | |
| # Створення анонімного ID | |
| patient_hash = hashlib.sha256(patient_info.encode()).hexdigest()[:16] | |
| # Видалення ідентифікаторів | |
| anonymized = patient_info | |
| # Замінюємо особистісні дані на плейсхолдери | |
| import re | |
| # Імена | |
| anonymized = re.sub(r'\b[A-Z][a-z]+ [A-Z][a-z]+\b', '[PATIENT_NAME]', anonymized) | |
| # Дати народження | |
| anonymized = re.sub(r'\b\d{1,2}/\d{1,2}/\d{4}\b', '[DATE_OF_BIRTH]', anonymized) | |
| # Номери телефонів | |
| anonymized = re.sub(r'\b\d{3}-\d{3}-\d{4}\b', '[PHONE_NUMBER]', anonymized) | |
| # Адреси | |
| anonymized = re.sub(r'\b\d+\s+[A-Za-z\s]+\b', '[ADDRESS]', anonymized) | |
| return patient_hash, anonymized | |
| def encrypt_diagnosis(self, diagnosis_data: str) -> bytes: | |
| """Шифрування діагностичних даних""" | |
| return self.cipher_suite.encrypt(diagnosis_data.encode()) | |
| def decrypt_diagnosis(self, encrypted_data: bytes) -> str: | |
| """Розшифрування діагностичних даних""" | |
| return self.cipher_suite.decrypt(encrypted_data).decode() | |
| def audit_log(self, action: str, user_id: str, patient_id: str): | |
| """Аудит логування для HIPAA compliance""" | |
| timestamp = datetime.now().isoformat() | |
| log_entry = { | |
| "timestamp": timestamp, | |
| "action": action, | |
| "user_id": user_id, | |
| "patient_id": patient_id, | |
| "ip_address": "masked_for_privacy" | |
| } | |
| # Записуємо в захищений лог файл | |
| with open("mai_dx_audit.log", "a") as f: | |
| f.write(json.dumps(log_entry) + "\n") | |
| # Приклад безпечного використання | |
| security = MAIDXSecurity() | |
| # Анонімізація даних перед діагностикою | |
| patient_id, anonymized_case = security.anonymize_patient_data(patient_info) | |
| # Аудит логування | |
| security.audit_log("diagnosis_started", "dr_smith", patient_id) | |
| # Шифрування результатів | |
| encrypted_diagnosis = security.encrypt_diagnosis(result.final_diagnosis) | |
| ``` | |
| --- | |
| ## 📚 API Reference | |
| ### Основний клас MaiDxOrchestrator | |
| ```python | |
| class MaiDxOrchestrator: | |
| """ | |
| Основний клас для медичної діагностики з використанням ШІ-агентів | |
| """ | |
| def __init__( | |
| self, | |
| model_name: str = "gemini/gemini-2.5-flash", | |
| max_iterations: int = 5, | |
| initial_budget: int = 3000, | |
| mode: str = "budgeted", | |
| verbose: bool = False | |
| ): | |
| """ | |
| Ініціалізація оркестратора | |
| Args: | |
| model_name: Назва LLM моделі | |
| max_iterations: Максимальна кількість діагностичних ітерацій | |
| initial_budget: Початковий бюджет у доларах | |
| mode: Режим роботи ("question_only", "budgeted", "no_budget") | |
| verbose: Детальний вивід логів | |
| """ | |
| def run( | |
| self, | |
| initial_case_info: str, | |
| full_case_details: str, | |
| ground_truth_diagnosis: str = None | |
| ) -> DiagnosisResult: | |
| """ | |
| Запуск діагностичного процесу | |
| Args: | |
| initial_case_info: Початкова інформація про випадок | |
| full_case_details: Повні деталі медичного випадку | |
| ground_truth_diagnosis: Еталонний діагноз для оцінювання | |
| Returns: | |
| DiagnosisResult: Результат діагностики | |
| """ | |
| def run_ensemble( | |
| self, | |
| initial_case_info: str, | |
| full_case_details: str, | |
| ground_truth_diagnosis: str, | |
| num_runs: int = 3 | |
| ) -> DiagnosisResult: | |
| """ | |
| Запуск ensemble діагностики (кілька незалежних сесій) | |
| Args: | |
| initial_case_info: Початкова інформація про випадок | |
| full_case_details: Повні деталі медичного випадку | |
| ground_truth_diagnosis: Еталонний діагноз | |
| num_runs: Кількість незалежних запусків | |
| Returns: | |
| DiagnosisResult: Консенсус результат | |
| """ | |
| ``` | |
| ### Структура DiagnosisResult | |
| ```python | |
| @dataclass | |
| class DiagnosisResult: | |
| """Результат діагностичного процесу""" | |
| final_diagnosis: str # Фінальний діагноз | |
| ground_truth: str # Еталонний діагноз | |
| accuracy_score: float # Оцінка точності (1.0-5.0) | |
| accuracy_reasoning: str # Обґрунтування оцінки | |
| total_cost: float # Загальна вартість діагностики | |
| iterations: int # Кількість проведених ітерацій | |
| # Додаткові поля (якщо доступні) | |
| differential_diagnoses: List[str] = None | |
| recommended_tests: List[str] = None | |
| questions_asked: List[str] = None | |
| reasoning_chain: List[str] = None | |
| ``` | |
| ### Utilities та Helper функції | |
| ```python | |
| def create_optimized_orchestrator( | |
| case_complexity: str = "medium", | |
| urgency: str = "routine", | |
| budget_limit: int = None | |
| ) -> MaiDxOrchestrator: | |
| """ | |
| Створення оптимізованого оркестратора базуючись на характеристиках випадку | |
| Args: | |
| case_complexity: "simple", "medium", "complex" | |
| urgency: "routine", "urgent", "emergency" | |
| budget_limit: Максимальний бюджет | |
| Returns: | |
| MaiDxOrchestrator: Налаштований оркестратор | |
| """ | |
| # Конфігурації для різних сценаріїв | |
| configs = { | |
| ("simple", "routine"): {"mode": "question_only", "budget": 1000, "iterations": 2}, | |
| ("simple", "urgent"): {"mode": "question_only", "budget": 1500, "iterations": 3}, | |
| ("medium", "routine"): {"mode": "budgeted", "budget": 3000, "iterations": 4}, | |
| ("medium", "urgent"): {"mode": "budgeted", "budget": 4000, "iterations": 5}, | |
| ("complex", "routine"): {"mode": "no_budget", "budget": 8000, "iterations": 6}, | |
| ("complex", "urgent"): {"mode": "no_budget", "budget": 10000, "iterations": 7}, | |
| ("complex", "emergency"): {"mode": "budgeted", "budget": 5000, "iterations": 3} # Швидко але ретельно | |
| } | |
| config = configs.get((case_complexity, urgency), configs[("medium", "routine")]) | |
| if budget_limit: | |
| config["budget"] = min(config["budget"], budget_limit) | |
| return MaiDxOrchestrator( | |
| mode=config["mode"], | |
| initial_budget=config["budget"], | |
| max_iterations=config["iterations"] | |
| ) | |
| def validate_medical_case(case_text: str) -> Dict[str, Any]: | |
| """ | |
| Валідація медичного випадку перед діагностикою | |
| Args: | |
| case_text: Текст медичного випадку | |
| Returns: | |
| Dict: Результат валідації з рекомендаціями | |
| """ | |
| validation_result = { | |
| "is_valid": True, | |
| "warnings": [], | |
| "suggestions": [], | |
| "estimated_complexity": "medium" | |
| } | |
| # Перевірки мінімальної інформації | |
| required_elements = ["age", "gender", "complaint", "history"] | |
| missing_elements = [] | |
| case_lower = case_text.lower() | |
| if not any(age_indicator in case_lower for age_indicator in ["year", "age", "old"]): | |
| missing_elements.append("age") | |
| if not any(gender_indicator in case_lower for gender_indicator in ["male", "female", "man", "woman"]): | |
| missing_elements.append("gender") | |
| if len(case_text.split()) < 20: | |
| validation_result["warnings"].append("Case description seems too brief") | |
| validation_result["suggestions"].append("Consider adding more clinical details") | |
| # Оцінка складності | |
| complexity_indicators = { | |
| "simple": ["headache", "cold", "fever", "cough"], | |
| "complex": ["multiple", "chronic", "rare", "syndrome", "differential"] | |
| } | |
| simple_count = sum(1 for indicator in complexity_indicators["simple"] if indicator in case_lower) | |
| complex_count = sum(1 for indicator in complexity_indicators["complex"] if indicator in case_lower) | |
| if complex_count > simple_count: | |
| validation_result["estimated_complexity"] = "complex" | |
| elif simple_count > 2: | |
| validation_result["estimated_complexity"] = "simple" | |
| return validation_result | |
| def format_diagnosis_report(result: DiagnosisResult, include_reasoning: bool = True) -> str: | |
| """ | |
| Форматування діагностичного звіту | |
| Args: | |
| result: Результат діагностики | |
| include_reasoning: Включати детальне обґрунтування | |
| Returns: | |
| str: Форматований звіт | |
| """ | |
| report_lines = [ | |
| "🏥 MAI-DX ДІАГНОСТИЧНИЙ ЗВІТ", | |
| "=" * 50, | |
| f"📅 Дата: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}", | |
| "", | |
| "📋 РЕЗУЛЬТАТИ:", | |
| f" 🎯 Діагноз: {result.final_diagnosis}", | |
| f" ⭐ Оцінка точності: {result.accuracy_score}/5.0", | |
| f" 💰 Загальна вартість: ${result.total_cost:,.2f}", | |
| f" 🔄 Ітерації: {result.iterations}", | |
| "" | |
| ] | |
| # Оцінка якості | |
| if result.accuracy_score >= 4.0: | |
| quality_assessment = "🎉 ВІДМІННО - Високоточний діагноз" | |
| elif result.accuracy_score >= 3.0: | |
| quality_assessment = "👍 ДОБРЕ - Правильний напрямок діагностики" | |
| elif result.accuracy_score >= 2.0: | |
| quality_assessment = "⚠️ ЗАДОВІЛЬНО - Частково правильний діагноз" | |
| else: | |
| quality_assessment = "❌ ПОТРЕБУЄ ПОЛІПШЕННЯ - Неточний діагноз" | |
| report_lines.extend([ | |
| f"📊 ОЦІНКА ЯКОСТІ: {quality_assessment}", | |
| "" | |
| ]) | |
| # Детальне обґрунтування | |
| if include_reasoning and result.accuracy_reasoning: | |
| report_lines.extend([ | |
| "💭 ОБҐРУНТУВАННЯ ОЦІНКИ:", | |
| result.accuracy_reasoning[:500] + ("..." if len(result.accuracy_reasoning) > 500 else ""), | |
| "" | |
| ]) | |
| # Рекомендації | |
| report_lines.extend([ | |
| "💡 РЕКОМЕНДАЦІЇ:", | |
| " • Верифікуйте діагноз з лікарем", | |
| " • Розгляньте додаткові тести при потребі", | |
| " • Цей ШІ-діагноз є допоміжним інструментом", | |
| "", | |
| "⚠️ ВІДМОВА ВІД ВІДПОВІДАЛЬНОСТІ:", | |
| " Цей діагноз згенеровано ШІ для освітніх/дослідницьких цілей.", | |
| " Не замінює професійну медичну консультацію.", | |
| "=" * 50 | |
| ]) | |
| return "\n".join(report_lines) | |
| ``` | |
| --- | |
| ## 📖 Підсумок | |
| MAI-DX Orchestrator - це потужний інструмент для медичної діагностики з використанням штучного інтелекту. Система дозволяє: | |
| ### ✅ Можливості | |
| - Проводити складну медичну діагностику з 8 спеціалізованими ШІ-агентами | |
| - Контролювати витрати на діагностичні процедури | |
| - Отримувати оцінку точності діагнозів | |
| - Працювати в різних режимах залежно від потреб | |
| - Інтегруватися в існуючі медичні системи | |
| ### ⚠️ Обмеження | |
| - Потребує API ключі для LLM сервісів (витрати) | |
| - Не замінює професійної медичної консультації | |
| - Призначено для освітніх та дослідницьких цілей | |
| - Може мати косметичні помилки виводу (Rich console) | |
| ### 🎯 Рекомендації | |
| - Використовуйте для навчання та досліджень | |
| - Завжди верифікуйте результати з медичними професіоналами | |
| - Дотримуйтесь стандартів конфіденційності (HIPAA/GDPR) | |
| - Регулярно оновлюйте систему та залежності | |
| ### 📞 Підтримка | |
| - Документація: [GitHub Repository](https://github.com/The-Swarm-Corporation/Open-MAI-Dx-Orchestrator) | |
| - Issues: [GitHub Issues](https://github.com/The-Swarm-Corporation/Open-MAI-Dx-Orchestrator/issues) | |
| - Дискусії: [GitHub Discussions](https://github.com/The-Swarm-Corporation/Open-MAI-Dx-Orchestrator/discussions) | |
| --- | |
| *Версія документації: 1.0 | Останнє оновлення: Липень 2025* |