PickYourLLM 0.3__py3-none-any.whl

pickyourllm-0.3.dist-info/METADATA

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: PickYourLLM
+Version: 0.3
+Summary: Pick Your LLM: Intelligent, Use-Case Aware LLM Model advisor for Optimal Performance and Cost
+Home-page: https://github.com/AmadeusITGroup/PickYourLLM
+Author: Ilias, Eoin
+Author-email: ilias.driouich@amadeus.com;eoin.thomas@amadeus.com
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=1.1.0
+Requires-Dist: numpy>=1.19.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+## PickYourLLM Framework
+
+#### - This framework helps you automatically select the most suitable Large Language Model (LLM) for a given business or technical use case.
+
+#### - It analyzes use case requirements (e.g., cost, latency, reasoning quality, context window, provider constraints), matches them against available LLMs, and ranks the best candidates based on weighted scoring.
+---
+
+## Features
+
+- **Use Case–Driven Selection:** Takes a natural-language description of a use case and extracts structured constraints and priorities.
+- **Constraint Extraction:** Uses advanced LLM models to normalize requirements into a standardized schema (provider, latency, cost, openness, tool calling, languages, etc.).
+- **Model Matching:** Filters candidate LLMs based on hard constraints such as provider restrictions, deployment type, language support, context window, and cost thresholds.
+- **Weighted Recommendation Engine:** Scores models using weighted dimensions such as cost, latency, reasoning, quality, throughput, tool-calling capability, and openness.
+- **Transparent Ranking:** Produces ranked recommendations with clear rationales explaining why each model was selected.
+---
+
+## How It Works
+
+The pipeline runs in sequential steps:
+
+- **Use Case Selection**  
+Choose from predefined scenarios (customer assistant, travel agent assistant, multilingual chatbot, internal copilot, etc.) or provide your own description.
+
+- **Requirement Extraction (LLM Agent)**  
+the use case is parsed into structured metadata, including:  
+Provider constraints  
+Deployment preferences  
+Latency and cost requirements  
+Language support  
+Reasoning / quality expectations  
+Tool-calling or multimodal needs  
+Priority weights across decision criteria  
+
+- **Model Filtering**  
+Candidate LLMs from the model catalog are filtered according to the extracted hard constraints.
+
+- **Scoring & Ranking**  
+The remaining models are scored using a weighted recommendation engine across the most relevant dimensions for the use case.
+
+- **Export**  
+Ranked recommendations are exported to CSV, along with the extracted use case metadata in JSON format for inspection.
+
+## Usage
+
+To use the tool, follow these steps:
+
+```bash
+pip install PickYourLLM
+
+PickYourLLM

pickyourllm-0.3.dist-info/RECORD

@@ -0,0 +1,8 @@
+pickyourllm-0.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+run/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+run/run.py,sha256=JQ760dTE29nvDJ4LKpHAF3BeADMyBPGzSrKqd0YNFcY,19073
+pickyourllm-0.3.dist-info/METADATA,sha256=qkG1xuR88i4xfOClICTe6kVOs77LwxPahaNbIlnLqUM,2889
+pickyourllm-0.3.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pickyourllm-0.3.dist-info/entry_points.txt,sha256=vXWc6ReWAhw0-Ot6peeYlAcfclaMZNOjwnVPxaJR0GQ,45
+pickyourllm-0.3.dist-info/top_level.txt,sha256=tQBPJqhSsNYOwSN0MsGjPCMH_yRYw3TZ2ZdJ0EXH_rk,4
+pickyourllm-0.3.dist-info/RECORD,,

pickyourllm-0.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pickyourllm-0.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+PickYourLLM = run.run:main

pickyourllm-0.3.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

pickyourllm-0.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+run

run/__init__.py

@@ -0,0 +1 @@
+

run/run.py

@@ -0,0 +1,483 @@
+import warnings
+warnings.filterwarnings("ignore")
+
+import json
+import os
+from typing import Dict, Any, List
+
+import pandas as pd
+from dotenv import load_dotenv
+from openai import AzureOpenAI
+
+
+def main():
+    # ----------------------------
+    # 1) Load environment
+    # ----------------------------
+    envfilepath = str(input("\nEnter the path to your env file: ").strip()) or ".env"
+    _ = load_dotenv(envfilepath)
+
+    openai_api_key = os.getenv("API_KEY")
+    openai_api_version = os.getenv("AZURE_OPENAI_API_VERSION")
+    azure_openai_endpoint = os.getenv("AZURE_ENDPOINT")
+    gpt_model_deployment_name = os.getenv("GPT_DEPLOYMENT_NAME", "gpt-4o")
+
+    if not openai_api_key or not openai_api_version or not azure_openai_endpoint:
+        raise ValueError(
+            "Missing Azure OpenAI environment variables. "
+            "Please check API_KEY, AZURE_OPENAI_API_VERSION, and AZURE_ENDPOINT."
+        )
+
+    client = AzureOpenAI(
+        api_version=openai_api_version,
+        azure_endpoint=azure_openai_endpoint,
+        api_key=openai_api_key,
+    )
+
+    def gpt_oneshot(prompt_sys: str, prompt_usr: str, temperature: float = 0.0) -> str:
+        prompt_sys = prompt_sys.replace("\n", " ")
+        prompt_usr = prompt_usr.replace("\n", " ")
+
+        response = client.chat.completions.create(
+            model=gpt_model_deployment_name,
+            temperature=temperature,
+            messages=[
+                {"role": "system", "content": prompt_sys},
+                {"role": "user", "content": prompt_usr},
+            ],
+        )
+        return response.choices[0].message.content
+
+    # ----------------------------
+    # 2) Example use cases
+    # ----------------------------
+    use_cases = [
+        "I want to develop a digital assistant for my customer (travel agency) that will assist travel agents in finding the cheapest price for travelers. The customer would like that the assistant is built only using OpenAI models with a SLO response time <5 sec. Also, we would like the solution to be as cost effective as possible.",
+        "I want to develop a digital assistant for my customer (hotel chain) that will assist travelers by recommending activities to do at their destination. I would like that my assistant use open-source models and have the best performance in reasoning. No need for a fast solution as long as it is accurate and can handle multiple concurrent calls.",
+        "I need an internal customer-support copilot for airline operations. It must support English and French, have strong tool-calling ability, moderate cost, and low hallucination risk. Latency matters but accuracy matters more.",
+        "I want a multilingual chatbot for e-commerce customer support. It should support Arabic, French, and English, be low cost, and offer acceptable response speed. Open-source models are preferred but not mandatory.",
+    ]
+
+    print("\nAvailable Use Cases:")
+    for i, uc in enumerate(use_cases):
+        print(f"[{i}] {uc}")
+
+    usecase = str(input("\nEnter the use case description, choose one above or enter a new one: ")).strip()
+    use_case_description = usecase
+    print(f"\nSelected use case:\n{use_case_description}\n")
+
+    # ----------------------------
+    # 3) Prompt for structured extraction
+    # ----------------------------
+    extraction_prompt = """
+    You are an expert metadata-extraction and model-selection agent.
+    Given a free-form LLM use case description, extract and return exactly the following JSON.
+    If a value cannot be determined, use null for strings/numbers/arrays or false for booleans.
+    Return only valid JSON and no explanations.
+
+    {
+      "constraints": {
+        "provider": <[string]|null>,
+        "deployment_type": <string|null>,
+        "open_weights": <boolean|null>,
+        "max_latency_sec": <float|null>,
+        "max_input_cost_per_1m_tokens": <float|null>,
+        "max_output_cost_per_1m_tokens": <float|null>,
+        "min_context_window": <int|null>,
+        "required_languages": <[string]|null>,
+        "must_support_tool_calling": <boolean|null>,
+        "must_support_multimodality": <boolean|null>,
+        "min_reasoning_score": <float|null>,
+        "min_quality_score": <float|null>,
+        "min_throughput_rps": <float|null>
+      },
+      "priorities": {
+        "cost": <float>,
+        "latency": <float>,
+        "reasoning": <float>,
+        "context_window": <float>,
+        "quality": <float>,
+        "tool_calling": <float>,
+        "throughput": <float>,
+        "openness": <float>
+      },
+      "use_case_profile": {
+        "category": <string>,
+        "primary_goal": <string>,
+        "risk_level": <string>,
+        "notes": <string|null>
+      }
+    }
+
+    Rules:
+    1. priorities must sum to 1.0
+    2. provider must be a list like ["openai"], ["anthropic"], ["mistral"], ["meta"], or null
+    3. deployment_type must be one of:
+       ["api", "self-hosted", "either", null]
+    4. risk_level must be one of:
+       ["Low", "Medium", "High"]
+    5. category can be one of:
+       ["chatbot", "assistant", "rag", "agent", "classification", "summarization",
+        "recommendation", "search", "copilot", "other"]
+    6. required_languages should be ISO-639-3 codes when possible, e.g. ["eng","fra","ara"]
+    7. If the user says "open-source models" or equivalent, set open_weights=true
+    8. If the user says "only OpenAI models", set provider=["openai"]
+    9. If latency is important but no exact threshold is provided, reflect that in priorities instead of inventing a hard threshold
+    10. If accuracy/reasoning is emphasized, increase reasoning and quality weights
+    11. If cost-effectiveness is emphasized, increase cost weight
+    12. If concurrency or scale is emphasized, increase throughput weight
+    13. If tool use / agent / API calling is implied, increase tool_calling weight and set must_support_tool_calling=true when clearly required
+
+    Return JSON only.
+    """
+
+    role = "You are an expert metadata-extraction and LLM selection agent."
+    task = extraction_prompt + "\nHere is the use case description:\n" + use_case_description
+    extracted = gpt_oneshot(role, task, temperature=0.0)
+
+    try:
+        params = json.loads(extracted)
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Model did not return valid JSON:\n{extracted}") from e
+
+    print("\nExtracted constraints:")
+    print(json.dumps(params["constraints"], indent=2))
+
+    print("\nExtracted priorities:")
+    print(json.dumps(params["priorities"], indent=2))
+
+    print("\nUse case profile:")
+    print(json.dumps(params["use_case_profile"], indent=2))
+
+    # ----------------------------
+    # 4) Read model catalog CSV
+    # ----------------------------
+    model_catalog_path = str(input("\nEnter path to the LLM model catalog CSV: ").strip())
+    if not os.path.exists(model_catalog_path):
+        raise FileNotFoundError(f"CSV not found: {model_catalog_path}")
+
+    df = pd.read_csv(model_catalog_path)
+
+    # Expected columns in CSV
+    expected_columns = [
+        "model_name",
+        "provider",
+        "deployment_type",
+        "open_weights",
+        "input_cost_per_1m_tokens",
+        "output_cost_per_1m_tokens",
+        "avg_latency_sec",
+        "context_window",
+        "reasoning_score",
+        "quality_score",
+        "tool_calling",
+        "multimodal",
+        "throughput_rps",
+        "languages",
+        "benchmark_source",
+        "release_date",
+    ]
+
+    missing_cols = [c for c in expected_columns if c not in df.columns]
+    if missing_cols:
+        raise ValueError(
+            "The model catalog CSV is missing the following required columns:\n"
+            + "\n".join(missing_cols)
+        )
+
+    # ----------------------------
+    # 5) Helpers
+    # ----------------------------
+    def parse_languages(value: Any) -> List[str]:
+        if pd.isna(value):
+            return []
+        if isinstance(value, list):
+            return [str(x).strip().lower() for x in value]
+        text = str(value).strip()
+        if not text:
+            return []
+        # Accept formats like "eng,fra" or '["eng","fra"]'
+        if text.startswith("[") and text.endswith("]"):
+            try:
+                arr = json.loads(text)
+                return [str(x).strip().lower() for x in arr]
+            except Exception:
+                pass
+        return [x.strip().lower() for x in text.split(",") if x.strip()]
+
+    def language_match_count(required: set, candidate_langs: List[str]) -> int:
+        candidate = {lang.split("-")[0].lower() for lang in candidate_langs}
+        return len(required & candidate)
+
+    def normalize_series(series: pd.Series, higher_is_better: bool = True) -> pd.Series:
+        s = pd.to_numeric(series, errors="coerce")
+        if s.isna().all():
+            return pd.Series([0.0] * len(series), index=series.index)
+
+        min_val = s.min()
+        max_val = s.max()
+
+        if pd.isna(min_val) or pd.isna(max_val) or min_val == max_val:
+            return pd.Series([1.0] * len(series), index=series.index)
+
+        normalized = (s - min_val) / (max_val - min_val)
+        return normalized if higher_is_better else 1 - normalized
+
+    def hard_filter_models(df_in: pd.DataFrame, req: Dict[str, Any]) -> pd.DataFrame:
+        df_filtered = df_in.copy()
+
+        # Normalize booleans
+        bool_cols = ["open_weights", "tool_calling", "multimodal"]
+        for col in bool_cols:
+            df_filtered[col] = df_filtered[col].astype(str).str.lower().map(
+                {"true": True, "false": False}
+            ).fillna(df_filtered[col])
+
+        # Provider
+        if req["provider"] is not None:
+            allowed = {x.strip().lower() for x in req["provider"]}
+            df_filtered = df_filtered[
+                df_filtered["provider"].astype(str).str.lower().isin(allowed)
+            ]
+
+        # Deployment type
+        if req["deployment_type"] is not None and req["deployment_type"] != "either":
+            df_filtered = df_filtered[
+                df_filtered["deployment_type"].astype(str).str.lower() == req["deployment_type"].lower()
+            ]
+
+        # Open weights
+        if req["open_weights"] is True:
+            df_filtered = df_filtered[df_filtered["open_weights"] == True]
+
+        # Hard thresholds
+        if req["max_latency_sec"] is not None:
+            tmp = df_filtered[df_filtered["avg_latency_sec"] <= req["max_latency_sec"]]
+            if not tmp.empty:
+                df_filtered = tmp
+
+        if req["max_input_cost_per_1m_tokens"] is not None:
+            tmp = df_filtered[
+                df_filtered["input_cost_per_1m_tokens"] <= req["max_input_cost_per_1m_tokens"]
+            ]
+            if not tmp.empty:
+                df_filtered = tmp
+
+        if req["max_output_cost_per_1m_tokens"] is not None:
+            tmp = df_filtered[
+                df_filtered["output_cost_per_1m_tokens"] <= req["max_output_cost_per_1m_tokens"]
+            ]
+            if not tmp.empty:
+                df_filtered = tmp
+
+        if req["min_context_window"] is not None:
+            tmp = df_filtered[df_filtered["context_window"] >= req["min_context_window"]]
+            if not tmp.empty:
+                df_filtered = tmp
+
+        if req["min_reasoning_score"] is not None:
+            tmp = df_filtered[df_filtered["reasoning_score"] >= req["min_reasoning_score"]]
+            if not tmp.empty:
+                df_filtered = tmp
+
+        if req["min_quality_score"] is not None:
+            tmp = df_filtered[df_filtered["quality_score"] >= req["min_quality_score"]]
+            if not tmp.empty:
+                df_filtered = tmp
+
+        if req["min_throughput_rps"] is not None:
+            tmp = df_filtered[df_filtered["throughput_rps"] >= req["min_throughput_rps"]]
+            if not tmp.empty:
+                df_filtered = tmp
+
+        if req["must_support_tool_calling"] is True:
+            tmp = df_filtered[df_filtered["tool_calling"] == True]
+            if not tmp.empty:
+                df_filtered = tmp
+
+        if req["must_support_multimodality"] is True:
+            tmp = df_filtered[df_filtered["multimodal"] == True]
+            if not tmp.empty:
+                df_filtered = tmp
+
+        # Languages: keep best matching subset
+        if req["required_languages"] is not None:
+            required = {x.strip().lower() for x in req["required_languages"]}
+            if required:
+                df_filtered["lang_match_count"] = df_filtered["languages"].apply(
+                    lambda x: language_match_count(required, parse_languages(x))
+                )
+                max_match = df_filtered["lang_match_count"].max()
+                if pd.notna(max_match):
+                    df_filtered = df_filtered[df_filtered["lang_match_count"] == max_match]
+
+        return df_filtered.reset_index(drop=True)
+
+    def compute_weighted_score(df_in: pd.DataFrame, priorities: Dict[str, float]) -> pd.DataFrame:
+        df_scored = df_in.copy()
+
+        # Normalize score components
+        df_scored["score_cost_input"] = normalize_series(
+            df_scored["input_cost_per_1m_tokens"], higher_is_better=False
+        )
+        df_scored["score_cost_output"] = normalize_series(
+            df_scored["output_cost_per_1m_tokens"], higher_is_better=False
+        )
+        df_scored["score_cost"] = (df_scored["score_cost_input"] + df_scored["score_cost_output"]) / 2
+
+        df_scored["score_latency"] = normalize_series(
+            df_scored["avg_latency_sec"], higher_is_better=False
+        )
+        df_scored["score_reasoning"] = normalize_series(
+            df_scored["reasoning_score"], higher_is_better=True
+        )
+        df_scored["score_context_window"] = normalize_series(
+            df_scored["context_window"], higher_is_better=True
+        )
+        df_scored["score_quality"] = normalize_series(
+            df_scored["quality_score"], higher_is_better=True
+        )
+        df_scored["score_throughput"] = normalize_series(
+            df_scored["throughput_rps"], higher_is_better=True
+        )
+
+        # Boolean scores
+        df_scored["score_tool_calling"] = df_scored["tool_calling"].astype(str).str.lower().map(
+            {"true": 1.0, "false": 0.0}
+        ).fillna(0.0)
+
+        df_scored["score_openness"] = df_scored["open_weights"].astype(str).str.lower().map(
+            {"true": 1.0, "false": 0.0}
+        ).fillna(0.0)
+
+        # Weighted global score
+        df_scored["global_score"] = (
+            priorities["cost"] * df_scored["score_cost"]
+            + priorities["latency"] * df_scored["score_latency"]
+            + priorities["reasoning"] * df_scored["score_reasoning"]
+            + priorities["context_window"] * df_scored["score_context_window"]
+            + priorities["quality"] * df_scored["score_quality"]
+            + priorities["tool_calling"] * df_scored["score_tool_calling"]
+            + priorities["throughput"] * df_scored["score_throughput"]
+            + priorities["openness"] * df_scored["score_openness"]
+        )
+
+        return df_scored
+
+    def build_explanation(row: pd.Series, priorities: Dict[str, float]) -> str:
+        top_dims = sorted(
+            [
+                ("cost", priorities["cost"]),
+                ("latency", priorities["latency"]),
+                ("reasoning", priorities["reasoning"]),
+                ("context_window", priorities["context_window"]),
+                ("quality", priorities["quality"]),
+                ("tool_calling", priorities["tool_calling"]),
+                ("throughput", priorities["throughput"]),
+                ("openness", priorities["openness"]),
+            ],
+            key=lambda x: x[1],
+            reverse=True,
+        )[:3]
+
+        reasons = []
+        for dim, _ in top_dims:
+            if dim == "cost":
+                reasons.append(
+                    f"cost input/output={row['input_cost_per_1m_tokens']}/{row['output_cost_per_1m_tokens']}"
+                )
+            elif dim == "latency":
+                reasons.append(f"latency={row['avg_latency_sec']} sec")
+            elif dim == "reasoning":
+                reasons.append(f"reasoning_score={row['reasoning_score']}")
+            elif dim == "context_window":
+                reasons.append(f"context_window={row['context_window']}")
+            elif dim == "quality":
+                reasons.append(f"quality_score={row['quality_score']}")
+            elif dim == "tool_calling":
+                reasons.append(f"tool_calling={row['tool_calling']}")
+            elif dim == "throughput":
+                reasons.append(f"throughput_rps={row['throughput_rps']}")
+            elif dim == "openness":
+                reasons.append(f"open_weights={row['open_weights']}")
+
+        return " | ".join(reasons)
+
+    # ----------------------------
+    # 6) Filter + score
+    # ----------------------------
+    filtered = hard_filter_models(df, params["constraints"])
+
+    if filtered.empty:
+        print("\nNo exact match found after hard filtering. Falling back to full catalog scoring.\n")
+        filtered = df.copy()
+
+    scored = compute_weighted_score(filtered, params["priorities"])
+    scored["recommendation_rationale"] = scored.apply(
+        lambda row: build_explanation(row, params["priorities"]), axis=1
+    )
+
+    ranked = scored.sort_values(
+        by=["global_score", "reasoning_score", "quality_score"],
+        ascending=[False, False, False]
+    ).reset_index(drop=True)
+
+    # ----------------------------
+    # 7) Save results
+    # ----------------------------
+    output_path = str(input("\nEnter output folder path: ").strip())
+    os.makedirs(output_path, exist_ok=True)
+
+    output_cols = [
+        "model_name",
+        "provider",
+        "deployment_type",
+        "open_weights",
+        "input_cost_per_1m_tokens",
+        "output_cost_per_1m_tokens",
+        "avg_latency_sec",
+        "context_window",
+        "reasoning_score",
+        "quality_score",
+        "tool_calling",
+        "multimodal",
+        "throughput_rps",
+        "languages",
+        "benchmark_source",
+        "release_date",
+        "global_score",
+        "recommendation_rationale",
+    ]
+
+    ranked[output_cols].to_csv(
+        os.path.join(output_path, "LLMAdvisor_BenchmarkResults.csv"),
+        index=False
+    )
+
+    # Save extracted request metadata as well
+    with open(os.path.join(output_path, "LLMAdvisor_ExtractedUseCase.json"), "w", encoding="utf-8") as f:
+        json.dump(params, f, indent=2, ensure_ascii=False)
+
+    # Display top results
+    print("\nTop 5 recommended models:\n")
+    print(
+        ranked[
+            [
+                "model_name",
+                "provider",
+                "global_score",
+                "input_cost_per_1m_tokens",
+                "output_cost_per_1m_tokens",
+                "avg_latency_sec",
+                "reasoning_score",
+                "quality_score",
+                "recommendation_rationale",
+            ]
+        ].head(5).to_string(index=False)
+    )
+
+    print(f"\nResults saved to: {output_path}")
+
+
+if __name__ == "__main__":
+    main()