dhti-cli 0.1.0 → 0.3.0

package/dist/commands/mimic.js

@@ -0,0 +1,157 @@
+import { Args, Command } from '@oclif/core';
+export default class Mimic extends Command {
+    static args = {
+        server: Args.string({ default: 'http://localhost/fhir/$import', description: 'Server URL to submit' }), // object with input, instruction (rationale in distillation), output
+    };
+    static description = 'Submit a FHIR request to a server';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        const { args, flags } = await this.parse(Mimic);
+        const mimic_request = `{
+
+  "resourceType": "Parameters",
+
+  "parameter": [ {
+
+    "name": "inputFormat",
+
+    "valueCode": "application/fhir+ndjson"
+
+  }, {
+
+    "name": "inputSource",
+
+    "valueUri": "http://example.com/fhir/"
+
+  }, {
+
+    "name": "storageDetail",
+
+    "part": [ {
+
+      "name": "type",
+
+      "valueCode": "https"
+
+    }, {
+
+      "name": "credentialHttpBasic",
+
+      "valueString": "admin:password"
+
+    }, {
+
+      "name": "maxBatchResourceCount",
+
+      "valueString": "500"
+
+    } ]
+
+  }, {
+
+    "name": "input",
+
+    "part": [ {
+
+      "name": "type",
+
+      "valueCode": "Observation"
+
+    }, {
+
+      "name": "url",
+
+      "valueUri": "https://physionet.org/files/mimic-iv-fhir-demo/2.0/mimic-fhir/ObservationLabevents.ndjson"
+
+    } ]
+
+  }, {
+
+    "name": "input",
+
+    "part": [ {
+
+      "name": "type",
+
+      "valueCode": "Medication"
+
+    }, {
+
+      "name": "url",
+
+      "valueUri": "https://physionet.org/files/mimic-iv-fhir-demo/2.0/mimic-fhir/Medication.ndjson"
+
+    } ]
+
+  }, {
+
+    "name": "input",
+
+    "part": [ {
+
+      "name": "type",
+
+      "valueCode": "Procedure"
+
+    }, {
+
+      "name": "url",
+
+      "valueUri": "https://physionet.org/files/mimic-iv-fhir-demo/2.0/mimic-fhir/Procedure.ndjson"
+
+    } ]
+
+  }, {
+
+    "name": "input",
+
+    "part": [ {
+
+      "name": "type",
+
+      "valueCode": "Condition"
+
+    }, {
+
+      "name": "url",
+
+      "valueUri": "https://physionet.org/files/mimic-iv-fhir-demo/2.0/mimic-fhir/Condition.ndjson"
+
+    } ]
+
+  }, {
+
+    "name": "input",
+
+    "part": [ {
+
+      "name": "type",
+
+      "valueCode": "Patient"
+
+    }, {
+
+      "name": "url",
+
+      "valueUri": "https://physionet.org/files/mimic-iv-fhir-demo/2.0/mimic-fhir/Patient.ndjson"
+
+    } ]
+
+  } ]
+
+}`;
+        // send a POST request to the server with the mimic_request body
+        const response = await fetch(args.server, {
+            body: mimic_request,
+            headers: {
+                'Content-Type': 'application/fhir+json',
+                Prefer: 'respond-async',
+            },
+            method: 'POST',
+        });
+        if (!response.ok) {
+            console.error(`Error: ${response.status} ${response.statusText}`);
+            return;
+        }
+    }
+}

package/dist/commands/synthetic.d.ts

@@ -0,0 +1,17 @@
+import { Command } from '@oclif/core';
+export default class Synthetic extends Command {
+    static args: {
+        input: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        output: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        prompt: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        inputField: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        maxCycles: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        maxRecords: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        outputField: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/synthetic.js

@@ -0,0 +1,88 @@
+import { Args, Command, Flags } from '@oclif/core';
+import fs from 'node:fs';
+import bootstrap from '../utils/bootstrap.js';
+import { ChainService } from '../utils/chain.js';
+export default class Synthetic extends Command {
+    static args = {
+        input: Args.string({ default: "", description: 'Input file to process' }), // object with input, instruction (rationale in distillation), output
+        output: Args.string({ description: 'Output file to write' }),
+        prompt: Args.string({ default: "", description: 'Prompt file to read' }),
+    };
+    static description = 'Generate synthetic data using LLM';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        inputField: Flags.string({ char: 'i', default: 'input', description: 'Input field to use', options: ['input', 'instruction', 'output'] }),
+        maxCycles: Flags.integer({ char: 'm', default: 0, description: 'Maximum number of cycles to run' }),
+        maxRecords: Flags.integer({ char: 'r', default: 10, description: 'Maximum number of records to generate' }),
+        outputField: Flags.string({ char: 'o', default: 'output', description: 'Output field to use', options: ['input', 'instruction', 'output'] }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Synthetic);
+        let prompt = "";
+        // read prompt file if provided
+        if (args.prompt)
+            prompt = fs.readFileSync(args.prompt ?? '', 'utf8');
+        const container = await bootstrap();
+        const chain = new ChainService(container);
+        // if no output file, exit with error
+        if (!args.output) {
+            console.log("Please provide an output file");
+            this.exit(1);
+        }
+        if (flags.maxCycles) { // No input file, can process in batches
+            const input = {
+                input: prompt,
+            };
+            let responses = [];
+            for (let i = 0; i < flags.maxCycles; i++) {
+                const response = await chain.Chain(input);
+                let cycle = [];
+                const jsonArrayMatch = response.match(/\[[^\]]*]/);
+                if (jsonArrayMatch) {
+                    try {
+                        cycle = JSON.parse(jsonArrayMatch[0]);
+                    }
+                    catch (error) {
+                        console.error('Failed to parse JSON array from response:', error);
+                    }
+                }
+                responses = responses.concat(cycle);
+                console.log(`Iteration ${i + 1}: Collected ${responses.length} records so far, ${flags.maxRecords - responses.length} to go`);
+                if (responses.length >= flags.maxRecords)
+                    break;
+            }
+            // convert to json
+            const jsonOutput = [];
+            for (const response of responses) {
+                jsonOutput.push({
+                    [flags.outputField]: response,
+                });
+            }
+            fs.writeFileSync(args.output ?? '', JSON.stringify(jsonOutput, null, 4));
+            console.log(`${args.output} has been created with ${flags.maxRecords} records`);
+        }
+        else { // Input file, process one by one
+            // read input file
+            const input = JSON.parse(fs.readFileSync(args.input ?? '', 'utf8'));
+            const responses = [];
+            // for each record in input file
+            for (const [i, record] of input.entries()) {
+                const chainInput = {
+                    input: record[flags.inputField],
+                    prompt,
+                };
+                const response = await chain.Chain(chainInput);
+                record[flags.outputField] = response;
+                responses.push(record);
+                if (responses.length >= flags.maxRecords)
+                    break;
+                console.log(`Processed ${i + 1} records so far, ${flags.maxRecords - responses.length} to go`);
+            }
+            // write to output file
+            fs.writeFileSync(args.output ?? '', JSON.stringify(responses, null, 4));
+            console.log(`${args.output} has been created with ${responses.length} records`);
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { Cards, handleBundle } from './utils/index.js';
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { Cards, handleBundle } from './utils/index.js';
+export { run } from '@oclif/core';

package/dist/resources/docker-compose-master.yml

@@ -0,0 +1,238 @@
+version: "3.7"
+
+services:
+  gateway:
+    image: beapen/dhti-gateway:latest
+    restart: "unless-stopped"
+    pull_policy: always
+    depends_on:
+      - frontend
+      - backend
+    ports:
+      - "80:80"
+      - "9000:80"
+
+
+  frontend:
+    image: openmrs/openmrs-reference-application-3-frontend:3.0.0-beta.17
+    # image: openmrs/openmrs-reference-application-3-frontend:${TAG:-3.0.0-beta.17} # dev3, qa, demo, 3.0.0-beta.18
+    ports:
+      - "8003:80"
+    restart: "unless-stopped"
+    pull_policy: always
+    environment:
+      SPA_PATH: /openmrs/spa
+      API_URL: /openmrs
+      SPA_CONFIG_URLS: /openmrs/spa/config-core_demo.json
+      SPA_DEFAULT_LOCALE:
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost/"]
+      timeout: 5s
+    depends_on:
+      - backend
+    # volumes:
+    #   - ./spa:/usr/share/nginx/html
+
+  backend:
+    image: openmrs/openmrs-reference-application-3-backend:${TAG:-3.0.0-beta.17} # dev3, qa, demo, 3.0.0-beta.18
+    ports:
+      - "8002:8080"
+    restart: "unless-stopped"
+    depends_on:
+      - openmrs-db
+    environment:
+      OMRS_CONFIG_MODULE_WEB_ADMIN: "true"
+      OMRS_CONFIG_AUTO_UPDATE_DATABASE: "true"
+      OMRS_CONFIG_CREATE_TABLES: "true"
+      OMRS_CONFIG_CONNECTION_SERVER: openmrs-db
+      OMRS_CONFIG_CONNECTION_DATABASE: openmrs
+      OMRS_CONFIG_CONNECTION_USERNAME: ${OPENMRS_DB_USER:-openmrs}
+      OMRS_CONFIG_CONNECTION_PASSWORD: ${OPENMRS_DB_PASSWORD:-openmrs}
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8080/openmrs"]
+      timeout: 5s
+    volumes:
+      - openmrs-data:/openmrs/data
+
+  openmrs-db:
+    image: mariadb:10.11.7
+    restart: "unless-stopped"
+    command: "mysqld --character-set-server=utf8 --collation-server=utf8_general_ci"
+    healthcheck:
+      test: "mysql --user=${OMRS_DB_USER:-openmrs} --password=${OMRS_DB_PASSWORD:-openmrs} --execute \"SHOW DATABASES;\""
+      interval: 3s
+      timeout: 1s
+      retries: 5
+    environment:
+      MYSQL_DATABASE: openmrs
+      MYSQL_USER: ${OMRS_DB_USER:-openmrs}
+      MYSQL_PASSWORD: ${OMRS_DB_PASSWORD:-openmrs}
+      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD:-openmrs}
+    volumes:
+      - openmrs-db:/var/lib/mysql
+
+  langserve:
+    image: beapen/genai:latest
+    pull_policy: always
+    ports:
+      - "8001:8001"
+    restart: "unless-stopped"
+    environment:
+      - OLLAMA_SERVER_URL==http://ollama:11434
+      - OLLAMA_WEBUI=http://ollama-webui:8080
+      - LANGFUSE_HOST=http://langfuse:3000
+      - LANGFUSE_PUBLIC_KEY=pk-lf-abcd
+      - LANGFUSE_SECRET_KEY=sk-lf-abcd
+
+  ollama:
+    image: ollama/ollama:latest
+    ports:
+      - 11434:11434
+    volumes:
+      - ollama-code:/code
+      - ollama-root:/root/.ollama
+    tty: true
+    restart: "unless-stopped"
+    environment:
+      - OLLAMA_ORIGINS=*
+
+  ollama-webui:
+    image: ghcr.io/open-webui/open-webui:main
+    volumes:
+      - ollama-webui:/app/backend/data
+    depends_on:
+      - ollama
+    ports:
+      - 8080:8080
+    environment:
+      - '/ollama/api=http://ollama:11434/api'
+    extra_hosts:
+      - host.docker.internal:host-gateway
+    restart: unless-stopped
+
+  fhir:
+    image: alphora/cqf-ruler:0.14.0 # includes cql
+    ports:
+      - 8005:8080
+    restart: "unless-stopped"
+    depends_on:
+      - postgres-db
+    environment:
+        - "spring.datasource.url=jdbc:postgresql://postgres-db:5432/postgres"
+        - "spring.datasource.username=postgres"
+        - "spring.datasource.password=postgres"
+        - "spring.datasource.driverClassName=org.postgresql.Driver"
+        - "spring.jpa.properties.hibernate.dialect=ca.uhn.fhir.jpa.model.dialect.HapiFhirPostgres94Dialect"
+        - "hapi.fhir.fhir_version=R4"
+        - "hapi.fhir.cors.allowed-origins=*"
+        - "hapi.fhir.cors.allowCredentials=true"
+        - "hapi.fhir.bulkdata.enabled=true"
+        - "hapi.fhir.bulk_export_enabled=true"
+        - "hapi.fhir.bulk_import_enabled=true"
+        - "hapi.fhir.enforce_referential_integrity_on_write=false"
+        - "hapi.fhir.enforce_referential_integrity_on_delete=false"
+
+  mcp-fhir:
+    image: beapen/fhir-mcp-server:1.0
+    ports:
+      - 8006:8000
+    restart: "unless-stopped"
+    depends_on:
+      - fhir
+    environment:
+      - FHIR_SERVER_BASE_URL="http://fhir:8005/baseR4"
+      - FHIR_SERVER_SCOPES="*"
+      - FHIR_SERVER_ACCESS_TOKEN="none"
+
+  cql-elm:
+    image: cqframework/cql-translation-service:latest
+    ports:
+      - 8091:8080
+    restart: "unless-stopped"
+
+  cql-web:
+    image: beapen/cql_runner:latest
+    ports:
+      - 8092:80
+    restart: "unless-stopped"
+    depends_on:
+      - fhir
+
+  langfuse:
+    image: ghcr.io/langfuse/langfuse:latest
+    depends_on:
+      - postgres-db
+    ports:
+      - "3000:3000"
+    environment:
+      - DATABASE_URL=postgresql://postgres:postgres@postgres-db:5432/postgres
+      - NEXTAUTH_SECRET=mysecret
+      - SALT=mysalt
+      - NEXTAUTH_URL=http://langfuse:3000
+      - TELEMETRY_ENABLED=${TELEMETRY_ENABLED:-false}
+      - LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES=${LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES:-false}
+
+  postgres-db:
+    image: postgres
+    restart: "unless-stopped"
+    environment:
+      - POSTGRES_USER=postgres
+      - POSTGRES_PASSWORD=postgres
+      - POSTGRES_DB=postgres
+    ports:
+      - 5432:5432
+    volumes:
+      - postgres-db:/var/lib/postgresql/data
+
+  redis:
+    image: redislabs/redisearch:2.8.8
+    ports:
+      - 6379:6379
+    restart: "unless-stopped"
+    volumes:
+      - redis-db:/data
+
+  redis-commander:
+    image: rediscommander/redis-commander:latest
+    restart: "unless-stopped"
+    environment:
+      - REDIS_HOSTS=local:redis:6379
+    ports:
+      - "8081:8081"
+
+  neo4j:
+    image: neo4j:5.1-enterprise
+    ports:
+      - 7474:7474
+      - 7687:7687
+    environment:
+      - NEO4J_AUTH=neo4j/password
+      - NEO4J_ACCEPT_LICENSE_AGREEMENT=yes
+      - NEO4J_PLUGINS=["apoc", "graph-data-science", "n10s"]
+      - NEO4J_dbms_security_procedures_unrestricted=apoc.*,gds.*,n10s.*
+      - NEO4J_dbms_security_procedures_whitelist=apoc.*,gds.*,n10s.*
+    restart: "unless-stopped"
+    volumes:
+      - neo4j-db:/data
+
+  fhirg:
+    image: beapen/fhirg:latest
+    ports:
+      - 8004:8080
+    restart: "unless-stopped"
+    environment:
+      - spring.neo4j.uri=bolt://neo4j:7687
+      - spring.neo4j.authentication.username=neo4j
+      - spring.neo4j.authentication.password=password
+
+
+volumes:
+  openmrs-data: ~
+  openmrs-db: ~
+  fhir-db: ~
+  postgres-db: ~
+  redis-db: ~
+  neo4j-db: ~
+  ollama-code: ~
+  ollama-root: ~
+  ollama-webui: ~

package/dist/resources/genai/Dockerfile

@@ -0,0 +1,27 @@
+# Use Python 3.12 slim as base image
+FROM python:3.12-slim AS base
+
+# Update package lists and install Git
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends git && \
+    rm -rf /var/lib/apt/lists/*
+    
+# Install uv
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /bin/uv
+
+# Set working directory
+WORKDIR /app
+
+# Copy pyproject.toml into the image
+COPY pyproject.toml /app/pyproject.toml
+COPY README.md /app/README.md
+
+# Install dependencies and generate uv.lock
+RUN uv sync --no-dev
+
+# Copy the project into the image
+COPY . /app
+
+
+# Run the server
+CMD ["uv", "run", "python", "app/server.py"]

package/dist/resources/genai/README.md

@@ -0,0 +1 @@
+# README

package/dist/resources/genai/app/bootstrap.py

@@ -0,0 +1,43 @@
+from kink import di
+from os import getenv
+from dotenv import load_dotenv
+from langchain_core.prompts import PromptTemplate
+from langchain_core.language_models.fake import FakeListLLM
+
+## Override the default configuration of elixirs here if needed
+
+
+def bootstrap():
+    load_dotenv()
+    fake_llm = FakeListLLM(responses=["Paris", "I don't know"])
+    di["main_prompt"] = PromptTemplate.from_template(
+        "Summarize the following in 100 words: {input}"
+    )
+    di["main_llm"] = fake_llm
+    di["cds_hook_discovery"] = {
+        "services": [
+            {
+                "id": "dhti-service",
+                "hook": "order-select",
+                "title": "MyOrg Order Assistant",
+                "description": "Provides suggestions and actions for selected draft orders, including handling CommunicationRequest resources.",
+                "prefetch": {
+                    "patient": "Patient/{{context.patientId}}",
+                    "draftOrders": "Bundle?patient={{context.patientId}}&status=draft",
+                },
+                "scopes": [
+                    "launch",
+                    "patient/Patient.read",
+                    "user/Practitioner.read",
+                    "patient/CommunicationRequest.read",
+                ],
+                "metadata": {
+                    "author": "MyOrg CDS Team",
+                    "version": "1.0.0",
+                    "supportedResources": [
+                        "CommunicationRequest",
+                    ],
+                },
+            }
+        ]
+    }

package/dist/resources/genai/app/server.py

@@ -0,0 +1,57 @@
+from fastapi import FastAPI
+from langserve import add_routes
+from langchain_core.runnables.config import RunnableConfig
+from dhti_elixir_base.cds_hook.routes import add_services, add_invokes
+from fastapi.middleware.cors import CORSMiddleware
+from mcp.server.fastmcp import FastMCP
+mcp_server = FastMCP(name="dhti-mcp-server")
+
+# ! DO NOT REMOVE THE COMMENT BELOW
+# DHTI_CLI_IMPORT
+import uvicorn
+
+# Comes after elixir bootstraps, so can override elixir configurations
+from bootstrap import bootstrap
+bootstrap()
+
+app = FastAPI(title="dhti-elixir-server")
+# Mount the MCP server's ASGI application at a specific path (Exposes /messages and /sse endpoints)
+app.mount("/langserve/mcp", mcp_server.sse_app())
+
+origins = [
+    "*",
+]
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Define a root endpoint
+@app.get("/langserve")
+async def read_root():
+    return {"message": "Hello from DHTI!"}
+
+try:
+    from langfuse import Langfuse
+    from langfuse.callback import CallbackHandler
+    langfuse_handler = CallbackHandler()
+    langfuse_handler.auth_check()
+    config = RunnableConfig(callbacks=[langfuse_handler])
+    # ! DO NOT REMOVE THE COMMENT BELOW
+    # DHTI_LANGFUSE_ROUTE
+
+except:
+    # ! DO NOT REMOVE THE COMMENT BELOW
+    # DHTI_NORMAL_ROUTE
+    x = True
+
+# ! DO NOT REMOVE THE COMMENT BELOW
+# DHTI_COMMON_ROUTE
+
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8001)