Upload folder using huggingface_hub

app.py

@@ -998,25 +998,71 @@ with col_input:
                 st.rerun()
 
         st.markdown("### Model Selection")
+
+        # Classification mode selector
+        classify_mode = st.radio(
+            "Classification Mode",
+            options=["Single Model", "Model Comparison", "Ensemble"],
+            horizontal=True,
+            key="classify_mode",
+            help="Single: one model. Comparison: see results from multiple models side-by-side. Ensemble: multiple models vote for consensus."
+        )
+
         model_tier = st.radio(
             "Model Tier",
             options=["Free Models", "Bring Your Own Key"],
             key="classify_model_tier"
         )
 
+        # Multi-model mode uses multiselect
+        is_multi_model = classify_mode in ["Model Comparison", "Ensemble"]
+
         if model_tier == "Free Models":
-            model_display = st.selectbox("Model", options=FREE_MODEL_DISPLAY_NAMES, key="classify_model")
-            model = FREE_MODELS_MAP[model_display]  # Convert to actual model name
+            if is_multi_model:
+                model_displays = st.multiselect(
+                    "Models (select 2+)",
+                    options=FREE_MODEL_DISPLAY_NAMES,
+                    default=[FREE_MODEL_DISPLAY_NAMES[0], FREE_MODEL_DISPLAY_NAMES[1]] if len(FREE_MODEL_DISPLAY_NAMES) >= 2 else FREE_MODEL_DISPLAY_NAMES[:1],
+                    key="classify_models_multi"
+                )
+                models_list = [FREE_MODELS_MAP[d] for d in model_displays]
+            else:
+                model_display = st.selectbox("Model", options=FREE_MODEL_DISPLAY_NAMES, key="classify_model")
+                model = FREE_MODELS_MAP[model_display]  # Convert to actual model name
+                models_list = [model]
             api_key = ""
         else:
-            model = st.selectbox("Model", options=PAID_MODEL_CHOICES, key="classify_model_paid")
+            if is_multi_model:
+                models_list = st.multiselect(
+                    "Models (select 2+)",
+                    options=PAID_MODEL_CHOICES,
+                    default=[PAID_MODEL_CHOICES[0], PAID_MODEL_CHOICES[1]] if len(PAID_MODEL_CHOICES) >= 2 else PAID_MODEL_CHOICES[:1],
+                    key="classify_models_multi_paid"
+                )
+            else:
+                model = st.selectbox("Model", options=PAID_MODEL_CHOICES, key="classify_model_paid")
+                models_list = [model]
             api_key = st.text_input("API Key", type="password", key="classify_api_key")
 
+        # Ensemble-specific options
+        if classify_mode == "Ensemble":
+            consensus_threshold = st.slider(
+                "Consensus Threshold",
+                min_value=0.0,
+                max_value=1.0,
+                value=0.5,
+                step=0.1,
+                key="consensus_threshold",
+                help="Minimum agreement ratio needed for consensus (0.5 = majority vote)"
+            )
+
         if st.button("Categorize Data", type="primary", use_container_width=True):
             if input_data is None:
                 st.error("Please upload data first")
             elif not categories_entered:
                 st.error("Please enter at least one category")
+            elif is_multi_model and len(models_list) < 2:
+                st.error("Please select at least 2 models for comparison/ensemble mode")
             else:
                 # Set up progress tracking
                 mode = None
@@ -1028,11 +1074,20 @@ with col_input:
                     }
                     mode = mode_mapping.get(pdf_mode, "image")
 
-                actual_api_key, provider = get_api_key(model, model_tier, api_key)
-                if not actual_api_key:
-                    st.error(f"{provider} API key not configured")
+                # Build models tuples list: [(model, source, api_key), ...]
+                models_tuples = []
+                api_key_error = None
+                for m in models_list:
+                    actual_key, provider = get_api_key(m, model_tier, api_key)
+                    if not actual_key:
+                        api_key_error = f"{provider} API key not configured for {m}"
+                        break
+                    m_source = get_model_source(m)
+                    models_tuples.append((m, m_source, actual_key))
+
+                if api_key_error:
+                    st.error(api_key_error)
                 else:
-                    model_source = get_model_source(model)
                     items_list = input_data if isinstance(input_data, list) else [input_data]
 
                     # Progress UI
@@ -1058,14 +1113,20 @@ with col_input:
                             status_text.text(f"Processing page {current_idx+1} of {total_pages} ({page_label}) ({progress*100:.0f}%){eta_str}")
 
                         try:
-                            result_df = catllm.classify_ensemble(
-                                survey_input=items_list,
-                                categories=categories_entered,
-                                models=[(model, model_source, actual_api_key)],
-                                input_description=description,
-                                pdf_mode=mode,
-                                progress_callback=pdf_progress_callback
-                            )
+                            # Build kwargs for classify_ensemble
+                            classify_kwargs = {
+                                "survey_input": items_list,
+                                "categories": categories_entered,
+                                "models": models_tuples,
+                                "input_description": description,
+                                "pdf_mode": mode,
+                                "progress_callback": pdf_progress_callback,
+                            }
+                            # Add consensus_threshold for ensemble mode
+                            if classify_mode == "Ensemble":
+                                classify_kwargs["consensus_threshold"] = consensus_threshold
+
+                            result_df = catllm.classify_ensemble(**classify_kwargs)
 
                             processing_time = time.time() - start_time
                             total_items = len(result_df)
@@ -1113,13 +1174,19 @@ with col_input:
                             status_text.text(f"Processing item {current_idx+1} of {total} ({progress*100:.0f}%){eta_str}")
 
                         try:
-                            result_df = catllm.classify_ensemble(
-                                survey_input=items_list,
-                                categories=categories_entered,
-                                models=[(model, model_source, actual_api_key)],
-                                input_description=description,
-                                progress_callback=item_progress_callback,
-                            )
+                            # Build kwargs for classify_ensemble
+                            classify_kwargs = {
+                                "survey_input": items_list,
+                                "categories": categories_entered,
+                                "models": models_tuples,
+                                "input_description": description,
+                                "progress_callback": item_progress_callback,
+                            }
+                            # Add consensus_threshold for ensemble mode
+                            if classify_mode == "Ensemble":
+                                classify_kwargs["consensus_threshold"] = consensus_threshold
+
+                            result_df = catllm.classify_ensemble(**classify_kwargs)
                             all_results = [result_df]
 
                             processing_time = time.time() - start_time
@@ -1154,13 +1221,21 @@ with col_input:
                             catllm_version = "unknown"
                         python_version = sys.version.split()[0]
 
+                        # For reports: create model string (single or list)
+                        if len(models_list) == 1:
+                            report_model = models_list[0]
+                            report_model_source = models_tuples[0][1]
+                        else:
+                            report_model = ", ".join(models_list)
+                            report_model_source = f"{classify_mode} ({len(models_list)} models)"
+
                         # Generate methodology report
                         pdf_path = generate_methodology_report_pdf(
                             categories=categories_entered,
-                            model=model,
+                            model=report_model,
                             column_name=description,
                             num_rows=len(result_df),
-                            model_source=model_source,
+                            model_source=report_model_source,
                             filename=original_filename,
                             success_rate=success_rate,
                             result_df=result_df,
@@ -1173,7 +1248,7 @@ with col_input:
                         )
 
                         # Generate code
-                        code = generate_classify_code(input_type_selected, description, categories_entered, model, model_source, mode)
+                        code = generate_classify_code(input_type_selected, description, categories_entered, report_model, report_model_source, mode)
 
                         st.session_state.results = {
                             'df': result_df,