Snapshot of PlanExe commit d87f74953d1699782df0d7e3bfad64b027ccf618

src/llm_factory.py

@@ -1,6 +1,7 @@
 import logging
 import os
 import json
+from dataclasses import dataclass
 from dotenv import dotenv_values
 from typing import Optional, Any, Dict
 from llama_index.core.llms.llm import LLM
@@ -11,13 +12,14 @@ from llama_index.llms.together import TogetherLLM
 from llama_index.llms.groq import Groq
 from llama_index.llms.lmstudio import LMStudio
 from llama_index.llms.openrouter import OpenRouter
+from src.llm_util.ollama_info import OllamaInfo
 
 # You can disable this if you don't want to send app info to OpenRouter.
 SEND_APP_INFO_TO_OPENROUTER = True
 
 logger = logging.getLogger(__name__)
 
-__all__ = ["get_llm", "get_available_llms"]
+__all__ = ["get_llm", "LLMInfo"]
 
 # Load .env values and merge with system environment variables.
 # This one-liner makes sure any secret injected by Hugging Face, like OPENROUTER_API_KEY
@@ -66,11 +68,58 @@ def substitute_env_vars(config: Dict[str, Any], env_vars: Dict[str, str]) -> Dic
 
     return process_item(config)
 
-def get_available_llms() -> list[str]:
-    """
-    Returns a list of available LLM names.
-    """
-    return list(_llm_configs.keys())
+@dataclass
+class LLMConfigItem:
+    id: str
+    label: str
+
+@dataclass
+class LLMInfo:
+    llm_config_items: list[LLMConfigItem]
+    is_ollama_running: bool
+    error_message_list: list[str]
+
+    @classmethod
+    def obtain_info(cls) -> 'LLMInfo':
+        """
+        Returns a list of available LLM names.
+        """
+        error_message_list = []
+        ollama_info = OllamaInfo.obtain_info()
+        if ollama_info.is_running == False:
+            print(f"Ollama is not running. Please start the Ollama service, in order to use the models via Ollama.")
+        elif ollama_info.error_message:
+            print(f"Error message: {ollama_info.error_message}")
+            error_message_list.append(ollama_info.error_message)
+
+        llm_config_items = []
+
+        for config_id, config in _llm_configs.items():
+            if config.get("class") != "Ollama":
+                item = LLMConfigItem(id=config_id, label=config_id)
+                llm_config_items.append(item)
+                continue
+            arguments = config.get("arguments", {})
+            model = arguments.get("model", None)
+
+            is_model_available = ollama_info.is_model_available(model)
+            if is_model_available:
+                label = config_id
+            else:
+                label = f"{config_id} ❌ unavailable"
+            
+            if ollama_info.is_running and not is_model_available:
+                error_message = f"Problem with config `\"{config_id}\"`: The model `\"{model}\"` is not available in Ollama. Compare model names in `llm_config.json` with the names available in Ollama."
+                error_message_list.append(error_message)
+            
+            item = LLMConfigItem(id=config_id, label=label)
+            llm_config_items.append(item)
+
+        return LLMInfo(
+            llm_config_items=llm_config_items, 
+            is_ollama_running=ollama_info.is_running,
+            error_message_list=error_message_list,
+        )
 
 def get_llm(llm_name: Optional[str] = None, **kwargs: Any) -> LLM:
     """

src/llm_util/ollama_info.py

@@ -0,0 +1,46 @@
+"""
+PROMPT> python -m src.llm_util.ollama_info
+"""
+from dataclasses import dataclass
+
+@dataclass
+class OllamaInfo:
+    """
+    Details about the Ollama service, including a list of available model names,
+    a flag indicating whether the service is running, and an optional error message.
+    """
+    model_names: list[str]
+    is_running: bool
+    error_message: str = None
+
+    @classmethod
+    def obtain_info(cls) -> 'OllamaInfo':
+        """Retrieves information about the Ollama service."""
+        try:
+            # Only import ollama if it's available
+            from ollama import ListResponse, list
+            list_response: ListResponse = list()
+        except ImportError as e:
+            error_message = f"OllamaInfo. The 'ollama' library was not found: {e}"
+            return OllamaInfo(model_names=[], is_running=False, error_message=error_message)
+        except ConnectionError as e:
+            error_message = f"OllamaInfo. Error connecting to Ollama: {e}"
+            return OllamaInfo(model_names=[], is_running=False, error_message=error_message)
+        except Exception as e:
+            error_message = f"OllamaInfo. An unexpected error occurred: {e}"
+            return OllamaInfo(model_names=[], is_running=False, error_message=error_message)
+
+        model_names = [model.model for model in list_response.models]
+        return OllamaInfo(model_names=model_names, is_running=True, error_message=None)
+    
+    def is_model_available(self, find_model: str) -> bool:
+        """Checks if a specific model is available in the list of model names."""
+        return find_model in self.model_names
+
+if __name__ == '__main__':
+    find_model = 'qwen2.5-coder:latest'
+    ollama_info = OllamaInfo.obtain_info()
+    print(f"Error message: {ollama_info.error_message}")
+    print(f'Is Ollama running: {ollama_info.is_running}')
+    found = ollama_info.is_model_available(find_model)
+    print(f'Has model {find_model}: {found}')

src/plan/app_text2plan.py

@@ -15,7 +15,7 @@ import logging
 import json
 from dataclasses import dataclass
 from math import ceil
-from src.llm_factory import get_available_llms
+from src.llm_factory import LLMInfo
 from src.plan.generate_run_id import generate_run_id, RUN_ID_PREFIX
 from src.plan.create_zip_archive import create_zip_archive
 from src.plan.filenames import FilenameEnum
@@ -28,6 +28,15 @@ from src.huggingface_spaces.is_huggingface_spaces import is_huggingface_spaces
 from src.huggingface_spaces.huggingface_spaces_browserstate_secret import huggingface_spaces_browserstate_secret
 from src.utils.time_since_last_modification import time_since_last_modification
 
+logger = logging.getLogger(__name__)
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler()
+    ]
+)
+
 # Slightly different behavior when running inside Hugging Face Spaces, where it's not possible to open a file explorer.
 # And it's multi-user, so we need to keep track of the state for each user.
 IS_HUGGINGFACE_SPACES = is_huggingface_spaces()
@@ -37,6 +46,7 @@ class Config:
     use_uuid_as_run_id: bool
     visible_top_header: bool
     visible_open_output_dir_button: bool
+    visible_llm_info: bool
     visible_openrouter_api_key_textbox: bool
     allow_only_openrouter_models: bool
     run_planner_check_api_key_is_provided: bool
@@ -48,16 +58,18 @@ CONFIG_LOCAL = Config(
     visible_top_header=True,
     visible_open_output_dir_button=True,
     visible_openrouter_api_key_textbox=False,
+    visible_llm_info=True,
     allow_only_openrouter_models=False,
     run_planner_check_api_key_is_provided=False,
     enable_purge_old_runs=False,
-    browser_state_secret=None, # Not used in local mode
+    browser_state_secret="insert-your-secret-here",
 )
 CONFIG_HUGGINGFACE_SPACES = Config(
     use_uuid_as_run_id=True,
     visible_top_header=False,
     visible_open_output_dir_button=False,
     visible_openrouter_api_key_textbox=True,
+    visible_llm_info=False,
     allow_only_openrouter_models=True,
     run_planner_check_api_key_is_provided=True,
     enable_purge_old_runs=True,
@@ -94,11 +106,27 @@ gradio_examples = []
 for prompt_item in all_prompts:
     gradio_examples.append([prompt_item.prompt])
 
-all_available_models = get_available_llms()
+llm_info = LLMInfo.obtain_info()
+logger.info(f"LLMInfo.is_ollama_running: {llm_info.is_ollama_running}")
+logger.info(f"LLMInfo.error_message_list: {llm_info.error_message_list}")
+
+trimmed_llm_config_items = []
 if CONFIG.allow_only_openrouter_models:
-    available_model_names = [model for model in all_available_models if model.startswith("openrouter")]
+    # On Hugging Face Spaces, show only openrouter models.
+    # Since it's not possible to run Ollama nor LM Studio.
+    trimmed_llm_config_items = [item for item in llm_info.llm_config_items if item.id.startswith("openrouter")]
 else:
-    available_model_names = all_available_models
+    trimmed_llm_config_items = llm_info.llm_config_items
+
+
+# Create tupples for the Gradio Radio buttons.
+available_model_names = []
+default_model_value = None
+for config_index, config_item in enumerate(trimmed_llm_config_items):
+    if config_index == 0:
+        default_model_value = config_item.id
+    tuple_item = (config_item.label, config_item.id)
+    available_model_names.append(tuple_item)
 
 def has_pipeline_complete_file(path_dir: str):
     """
@@ -147,7 +175,7 @@ class SessionState:
         # Settings: the user's OpenRouter API key.
         self.openrouter_api_key = "" # Initialize to empty string
         # Settings: The model that the user has picked.
-        self.llm_model = available_model_names[0]
+        self.llm_model = default_model_value
         # Settings: The speedvsdetail that the user has picked.
         self.speedvsdetail = SpeedVsDetailEnum.ALL_DETAILS_BUT_SLOW
         # Holds the subprocess.Popen object for the currently running pipeline process.
@@ -173,7 +201,7 @@ def initialize_browser_settings(browser_state, session_state: SessionState):
     except Exception:
         settings = {}
     openrouter_api_key = settings.get("openrouter_api_key_text", "")
-    model = settings.get("model_radio", available_model_names[0])
+    model = settings.get("model_radio", default_model_value)
     speedvsdetail = settings.get("speedvsdetail_radio", SpeedVsDetailEnum.ALL_DETAILS_BUT_SLOW)
     session_state.openrouter_api_key = openrouter_api_key
     session_state.llm_model = model
@@ -442,9 +470,18 @@ with gr.Blocks(title="PlanExe") as demo_text2plan:
                 )
 
     with gr.Tab("Settings"):
+        if CONFIG.visible_llm_info:
+            if llm_info.is_ollama_running == False:
+                gr.Markdown("**Ollama is not running**, so Ollama models are unavailable. Please start Ollama to use them.")
+
+            if len(llm_info.error_message_list) > 0:
+                gr.Markdown("**Error messages:**")
+                for error_message in llm_info.error_message_list:
+                    gr.Markdown(f"- {error_message}")
+
         model_radio = gr.Radio(
             available_model_names,
-            value=available_model_names[0],
+            value=default_model_value,
             label="Model",
             interactive=True 
         )
@@ -556,14 +593,6 @@ with gr.Blocks(title="PlanExe") as demo_text2plan:
     )
 
 def run_app_text2plan():
-    logging.basicConfig(
-        level=logging.INFO,
-        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-        handlers=[
-            logging.StreamHandler()
-        ]
-    )
-
     if CONFIG.enable_purge_old_runs:
         start_purge_scheduler(run_dir=os.path.abspath(RUN_DIR), purge_interval_seconds=60*60, prefix=RUN_ID_PREFIX)
 

src/plan/data/simple_plan_prompts.jsonl

@@ -21,7 +21,8 @@
 {"id": "d3e10877-446f-4eb0-8027-864e923973b0", "prompt": "Construct a train bridge between Denmark and England.", "tags": ["denmark", "england", "bridge"]}
 {"id": "9fbb7ff9-5dc3-44f4-9823-dba3f31d3661", "prompt": "Write a Python script for a bouncing yellow ball within a square. Make sure to handle collision detection. Make the square slightly rotate. Implement it in Python. Make sure the ball stays within the square.", "tags": ["programming", "python", "collision detection"]}
 {"id": "676cbca8-5d49-42a0-8826-398318004703", "prompt": "Write a Python script for a snake shape keep bouncing within a pentagon. Make sure to handle collision detection properly. Make the pentagon slowly rotate.", "tags": ["programming", "python", "collision detection"]}
-{"id": "a9113924-6148-4a0c-b72a-eecdb856e1e2", "prompt": "Investigate outbreak of a deadly new disease in the jungle.", "tags": ["outbreak", "jungle"]}
+{"id": "a9113924-6148-4a0c-b72a-eecdb856e1e2", "prompt": "Investigate outbreak of a deadly new disease in the jungle.", "tags": ["outbreak", "jungle", "emergency"]}
+{"id": "d68da41f-9341-40c0-85ee-7fc9181271d1", "prompt": "Eradication of Oak Processionary Caterpillars. It was discovered in Denmark for the first time just under three weeks ago, with around 800 nests found in trees in southeastern Odense. You suffocate from the caterpillar’s toxic hairs. Limit the outbreak as quick as possible.", "tags": ["outbreak", "toxic", "caterpillar", "emergency"]}
 {"id": "4dc34d55-0d0d-4e9d-92f4-23765f49dd29", "prompt": "Establish a solar farm in Denmark.", "tags": ["denmark", "energy", "sun"]}
 {"id": "0bb4a7d3-c16b-4b21-8a9b-20e1cd4002d4", "prompt": "Develop a sustainable solution for extreme poverty in regions where people live on less than 2 USD per day. Focus on improving access to basic necessities like food, shelter, and clean water, and explain how you would allocate investments given that sectors like infrastructure may require higher per capita funding. Indicate whether your approach leverages existing systems or builds new capacity. Assume this initiative will impact 5 million people over 5 years with a total budget of 500 million USD.", "tags": ["poverty", "sustainability", "development"]}
 {"id": "307f7e0c-a160-4b7a-9e3c-76577164497e", "prompt": "Create a comprehensive plan to address hunger and malnutrition in impoverished communities by enhancing food security and nutritional education. Provide a detailed cost breakdown and clarify which components might need additional per capita investment. State whether you will leverage existing food distribution networks or develop new infrastructure. Assume the plan targets 3 million individuals across 10 countries with a total budget of 300 million USD over 4 years.", "tags": ["hunger", "malnutrition", "nutrition"]}
@@ -29,7 +30,7 @@
 {"id": "08505146-b6ad-4d7c-b6b6-85c2868e707d", "prompt": "Design an initiative to improve sanitation in both slums and rural areas to reduce disease spread and enhance living conditions. Provide a detailed allocation plan that accounts for the varying needs of urban versus rural contexts, and note that phased investments may be necessary for sustainable infrastructure. Assume the initiative will reach 1.5 million people in 50 different locations over 5 years with a total budget of 150 million USD.", "tags": ["sanitation", "health", "slums"]}
 {"id": "0bb00fe6-711c-4612-8f83-a9a88e5c7958", "prompt": "Establish accessible healthcare systems in regions where medical facilities are scarce, focusing on both preventive care and emergency services. Clarify whether your approach involves upgrading existing facilities or constructing new ones, and account for the typically higher per capita costs in healthcare infrastructure. Assume the program will cover 4 million people in 20 countries over 6 years with a total budget of 400 million USD.", "tags": ["healthcare", "accessibility", "medicine"]}
 {"id": "79b62957-cae7-4727-8450-4f5f29d4ddda", "prompt": "Create a detailed plan to increase educational opportunities in poverty-stricken areas. This plan should include building or improving schools, teacher training, and scholarship programs, with a clear breakdown of resource allocation among these components. Recognize that educational initiatives may require higher per capita investments for infrastructure compared to service-based interventions. Assume the plan will support 1 million students over 7 years with a total budget of 350 million USD.", "tags": ["education", "literacy", "development"]}
-{"id": "6f7a8b9c-0d1e-2f3a-4b5c-6d7e8f90a1b2", "prompt": "Develop comprehensive policies and programs to eradicate child labor by ensuring children have access to education and protection from exploitation. Include details on scaling the initiative and allocating funds among enforcement, educational support, and social services. Assume this effort will benefit 500,000 children in 15 countries over 5 years with a total budget of 100 million USD.", "tags": ["child labor", "education", "protection"]}
+{"id": "1382d4a1-5eb0-42f3-b93a-74c066ae1c97", "prompt": "Develop comprehensive policies and programs to eradicate child labor by ensuring children have access to education and protection from exploitation. Include details on scaling the initiative and allocating funds among enforcement, educational support, and social services. Assume this effort will benefit 500,000 children in 15 countries over 5 years with a total budget of 100 million USD.", "tags": ["child labor", "education", "protection"]}
 {"id": "a9f410c0-120e-45d6-b042-e88ca47b39bb", "prompt": "Formulate a housing security plan that addresses overcrowding, unsafe living conditions, and homelessness by promoting secure and dignified housing. Clarify whether the initiative involves new construction, rehabilitation of existing structures, or a combination of both, and outline a phased investment strategy given the higher costs typically associated with housing projects. Assume the plan will provide housing for 200,000 individuals over 4 years with a total budget of 250 million USD.", "tags": ["housing", "security", "urban development"]}
 {"id": "cdf7f29d-bbcb-478d-8b5a-e82e74ed8626", "prompt": "Propose comprehensive peace initiatives and conflict resolution strategies for areas experiencing high rates of violence and political instability. Detail how your approach will protect vulnerable populations, including mechanisms for community engagement, reconciliation, and rebuilding. Assume the intervention will affect 1 million people in conflict zones over 3 years with a total budget of 150 million USD.", "tags": ["conflict", "peace", "stability"]}
 {"id": "79ef9ebf-3173-4b33-81f9-abbd3da7da6d", "prompt": "Design robust adaptation and resilience programs for communities facing environmental degradation and the effects of climate change, especially in disaster-prone regions. Include both short-term relief measures and long-term sustainability strategies, and provide details on how funds will be allocated between immediate response and infrastructure improvements. Assume the initiative will aid 1.2 million people in the 10 most affected countries over 5 years with a total budget of 180 million USD.", "tags": ["environment", "climate change", "resilience"]}

src/prompt/prompt_catalog.py

@@ -52,7 +52,7 @@ class PromptCatalog:
                     continue
 
                 if not is_valid_uuid(pid):
-                    logger.error(f"Invalid UUID in {filepath} at line {line_num}: {pid}. Skipping row.")
+                    logger.error(f"Invalid UUID in {filepath} at line {line_num}: '{pid}'. Skipping row.")
                     continue
 
                 tags = data.get('tags', [])

src/proof_of_concepts/run_ping.py

@@ -0,0 +1,61 @@
+"""
+Ping the LLM to check if it is running.
+
+PROMPT> python -m src.proof_of_concepts.run_ping
+"""
+from src.llm_factory import get_llm
+from llama_index.core.llms import ChatMessage
+import json
+from pydantic import BaseModel
+from llama_index.core.llms import ChatMessage, MessageRole
+
+model = "ollama-llama3.1"
+
+llm = get_llm(model)
+
+user_prompt = "location=unspecified, eventcount=8, weather=rainy, role=agent, state=empty, name=Simon"
+
+PING_SYSTEM_PROMPT = """
+You are an expert at extracting specific details from unstructured data and mapping them to predefined fields. Your task is to identify and extract the values related to weather, event_count, and state from the input data, and then assign those values to the corresponding fields in a Python dictionary.
+
+Even if the labels in the input data are slightly different from the field names, you should use your understanding of the data to map the values correctly. For example, "eventcnt" should be mapped to the "event_count" field.
+
+Example Input:
+age=77, eventcount=5, id=1809246, climate=cold, role=freighter, status=active, name=Ripley, location=Nostromo
+
+Example Output:
+{'weather': 'cold', 'count': '5', 'state': 'active'}
+
+Example Input:
+name=Bob, location=Paris, attendees=100, condition=hot, state=finish
+
+Example Output:
+{'weather': 'hot', 'count': '100', 'state': 'finish'}
+"""
+
+class ExtractDetails(BaseModel):
+    weather: str = "sunshine"
+    count: str = "999"
+    state: str = "start"
+
+system_prompt = PING_SYSTEM_PROMPT.strip()
+
+chat_message_list = [
+    ChatMessage(
+        role=MessageRole.SYSTEM,
+        content=system_prompt,
+    ),
+    ChatMessage(
+        role=MessageRole.USER,
+        content=user_prompt,
+    )
+]
+sllm = llm.as_structured_llm(ExtractDetails)
+chat_response = sllm.chat(chat_message_list)
+
+raw = chat_response.raw
+#print(f"raw:\n{raw}\n\n")
+
+json_data = raw.model_dump()
+print(json.dumps(json_data, indent=2))
+

src/swot/app_swot_analysis.py

@@ -4,31 +4,51 @@ PROMPT> python -m src.swot.app_swot_analysis
 import gradio as gr
 import os
 import json
+import logging
 from typing import List, Optional
 from src.swot.swot_analysis import SWOTAnalysis
-from src.llm_factory import get_llm, get_available_llms
+from src.llm_factory import LLMInfo, get_llm
 from src.prompt.prompt_catalog import PromptCatalog
 
+logger = logging.getLogger(__name__)
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler()
+    ]
+)
+
 DEFAULT_PROMPT_UUID = "427e5163-cefa-46e8-b1d0-eb12be270e19"
 
 prompt_catalog = PromptCatalog()
 prompt_catalog.load(os.path.join(os.path.dirname(__file__), 'data', 'example_swot_prompt.jsonl'))
 
-# Prefill the input box with the default prompt
-default_prompt_item = prompt_catalog.find(DEFAULT_PROMPT_UUID)
-if default_prompt_item:
-    gradio_default_example = default_prompt_item.prompt
-else:
-    raise ValueError("DEFAULT_PROMPT_UUID prompt not found.")
-
 # Show all prompts in the catalog as examples
 all_prompts = prompt_catalog.all()
 gradio_examples = []
 for prompt_item in all_prompts:
     gradio_examples.append([prompt_item.prompt])
 
-available_models = get_available_llms()
-available_model_names = [model for model in available_models]
+llm_info = LLMInfo.obtain_info()
+logger.info(f"LLMInfo.is_ollama_running: {llm_info.is_ollama_running}")
+logger.info(f"LLMInfo.error_message_list: {llm_info.error_message_list}")
+
+# Create tupples for the Gradio Radio buttons.
+available_model_names = []
+default_model_value = None
+for config_index, config_item in enumerate(llm_info.llm_config_items):
+    if config_index == 0:
+        default_model_value = config_item.id
+    tuple_item = (config_item.label, config_item.id)
+    available_model_names.append(tuple_item)
+
+# Prefill the input box with the default prompt
+default_prompt_item = prompt_catalog.find(DEFAULT_PROMPT_UUID)
+if default_prompt_item:
+    gradio_default_example = default_prompt_item.prompt
+else:
+    raise ValueError("DEFAULT_PROMPT_UUID prompt not found.")
 
 def make_swot(prompt_description, model_id, model_temperature):
     temperature_float = float(model_temperature) / 100.0
@@ -72,7 +92,7 @@ with gr.Blocks(title="SWOT") as demo:
     with gr.Tab("Settings"):
         model_radio = gr.Radio(
             available_model_names,
-            value=available_model_names[0],
+            value=default_model_value,
             label="Model",
             interactive=True 
         )

src/uuid_util/tests/test_is_valid_uuid.py

@@ -3,7 +3,12 @@ import uuid
 from src.uuid_util.is_valid_uuid import is_valid_uuid
 
 class TestIsValidUUID(unittest.TestCase):
-    def test_valid_uuid(self):
+    def test_valid_uuid_hardcoded(self):
+        """Test that a proper UUID (version 4) returns True."""
+        valid_uuid = "1382d4a1-5eb0-42f3-b93a-74c066ae1c97"
+        self.assertTrue(is_valid_uuid(valid_uuid))
+        
+    def test_valid_uuid_generated(self):
         """Test that a proper UUID (version 4) returns True."""
         valid_uuid = str(uuid.uuid4())
         self.assertTrue(is_valid_uuid(valid_uuid))