Remove old endpoints

api/solutions.py

@@ -7,13 +7,13 @@ from jinja2 import Environment
 from litellm.router import Router
 from dependencies import INSIGHT_FINDER_BASE_URL, get_http_client, get_llm_router, get_prompt_templates
 from typing import Awaitable, Callable, TypeVar
-from schemas import _RefinedSolutionModel, _ReqGroupingCategory, _ReqGroupingOutput, _SearchedSolutionModel, _SolutionCriticismOutput, CriticizeSolutionsRequest, CritiqueResponse, InsightFinderConstraintsList, ReqGroupingCategory, ReqGroupingRequest, ReqGroupingResponse, ReqSearchLLMResponse, ReqSearchRequest, ReqSearchResponse, SolutionCriticism, SolutionModel, SolutionSearchResponse, SolutionSearchV2Request, TechnologyData
+from schemas import _RefinedSolutionModel,  _SearchedSolutionModel, _SolutionCriticismOutput, CriticizeSolutionsRequest, CritiqueResponse, InsightFinderConstraintsList, ReqGroupingCategory, ReqGroupingRequest, ReqGroupingResponse, ReqSearchLLMResponse, ReqSearchRequest, ReqSearchResponse, SolutionCriticism, SolutionModel, SolutionSearchResponse, SolutionSearchV2Request, TechnologyData
 
 # Router for solution generation and critique
 router = APIRouter(tags=["solution generation and critique"])
 
 
-# ============== utilities =======================
+# ============== utilities ===========================
 T = TypeVar("T")
 A = TypeVar("A")
 
@@ -32,68 +32,65 @@ async def retry_until(
         last_value = await func(arg)
     return last_value
 
-# =================================================
+# =================================================== Search solutions ============================================================================
 
+@router.post("/search_solutions")
+async def search_solutions_if(req: SolutionSearchV2Request, prompt_env: Environment = Depends(get_prompt_templates), llm_router: Router = Depends(get_llm_router), http_client: AsyncClient = Depends(get_http_client)) -> SolutionSearchResponse:
 
-@router.post("/search_solutions_gemini/v2", response_model=SolutionSearchResponse)
-async def search_solutions(params: SolutionSearchV2Request, prompt_env: Environment = Depends(get_prompt_templates), llm_router: Router = Depends(get_llm_router)) -> SolutionSearchResponse:
-    """Searches solutions solving the given grouping params and respecting the user constraints using Gemini and grounded on google search"""
-
-    logging.info(f"Searching solutions for categories: {params}")
+    async def _search_solution_inner(cat: ReqGroupingCategory):
+        # process requirements into insight finder format
+        fmt_completion = await llm_router.acompletion("gemini-v2", messages=[
+            {
+                "role": "user",
+                "content": await prompt_env.get_template("format_requirements.txt").render_async(**{
+                    "category": cat.model_dump(),
+                    "response_schema": InsightFinderConstraintsList.model_json_schema()
+                })
+            }], response_format=InsightFinderConstraintsList)
 
-    async def _search_inner(cat: ReqGroupingCategory) -> SolutionModel:
-        # ================== generate the solution with web grounding
-        req_prompt = await prompt_env.get_template("search_solution_v2.txt").render_async(**{
-            "category": cat.model_dump(),
-            "user_constraints": params.user_constraints,
-        })
+        fmt_model = InsightFinderConstraintsList.model_validate_json(
+            fmt_completion.choices[0].message.content)
 
-        # generate the completion in non-structured mode.
-        # the googleSearch tool enables grounding gemini with google search
-        # this also forces gemini to perform a tool call
-        req_completion = await llm_router.acompletion(model="gemini-v2", messages=[
-            {"role": "user", "content": req_prompt}
-        ], tools=[{"googleSearch": {}}], tool_choice="required")
+        # translate from a structured output to a dict for insights finder
+        formatted_constraints = {'constraints': {
+            cons.title: cons.description for cons in fmt_model.constraints}}
 
-        # ==================== structure the solution as a json ===================================
+        # fetch technologies from insight finder
+        technologies_req = await http_client.post(INSIGHT_FINDER_BASE_URL + "process-constraints", content=json.dumps(formatted_constraints))
+        technologies = TechnologyData.model_validate(technologies_req.json())
 
-        structured_prompt = await prompt_env.get_template("structure_solution.txt").render_async(**{
-            "solution": req_completion.choices[0].message.content,
-            "response_schema": _SearchedSolutionModel.model_json_schema()
-        })
+        # =============================================================== synthesize solution using LLM =========================================
 
-        structured_completion = await llm_router.acompletion(model="gemini-v2", messages=[
-            {"role": "user", "content": structured_prompt}
+        format_solution = await llm_router.acompletion("gemini-v2", messages=[{
+            "role": "user",
+            "content": await prompt_env.get_template("synthesize_solution.txt").render_async(**{
+                "category": cat.model_dump(),
+                "technologies": technologies.model_dump()["technologies"],
+                "user_constraints": req.user_constraints,
+                "response_schema": _SearchedSolutionModel.model_json_schema()
+            })}
         ], response_format=_SearchedSolutionModel)
-        solution_model = _SearchedSolutionModel.model_validate_json(
-            structured_completion.choices[0].message.content)
-
-        # ======================== build the final solution object ================================
 
-        sources_metadata = []
-        # extract the source metadata from the search items, if gemini actually called the tools to search .... and didn't hallucinated
-        try:
-            sources_metadata.extend([{"name": a["web"]["title"], "url": a["web"]["uri"]}
-                                     for a in req_completion["vertex_ai_grounding_metadata"][0]['groundingChunks']])
-        except KeyError as ke:
-            pass
+        format_solution_model = _SearchedSolutionModel.model_validate_json(
+            format_solution.choices[0].message.content)
 
-        final_sol = SolutionModel(
+        final_solution = SolutionModel(
             Context="",
             Requirements=[
-                cat.requirements[i].requirement for i in solution_model.requirement_ids
+                cat.requirements[i].requirement for i in format_solution_model.requirement_ids
             ],
-            Problem_Description=solution_model.problem_description,
-            Solution_Description=solution_model.solution_description,
-            References=sources_metadata,
+            Problem_Description=format_solution_model.problem_description,
+            Solution_Description=format_solution_model.solution_description,
+            References=[],
             Category_Id=cat.id,
         )
-        return final_sol
 
-    solutions = await asyncio.gather(*[retry_until(_search_inner, cat, lambda v: len(v.References) > 0, 2) for cat in params.categories], return_exceptions=True)
-    logging.info(solutions)
-    final_solutions = [
-        sol for sol in solutions if not isinstance(sol, Exception)]
+        # ========================================================================================================================================
+
+        return final_solution
+
+    tasks = await asyncio.gather(*[_search_solution_inner(cat) for cat in req.categories], return_exceptions=True)
+    final_solutions = [sol for sol in tasks if not isinstance(sol, Exception)]
 
     return SolutionSearchResponse(solutions=final_solutions)
 
@@ -155,65 +152,3 @@ async def refine_solutions(params: CritiqueResponse, prompt_env: Environment = D
 
     return SolutionSearchResponse(solutions=refined_solutions)
 
-# =============================================================== Search solutions =========================================
-
-
-@router.post("/search_solutions_if")
-async def search_solutions_if(req: SolutionSearchV2Request, prompt_env: Environment = Depends(get_prompt_templates), llm_router: Router = Depends(get_llm_router), http_client: AsyncClient = Depends(get_http_client)) -> SolutionSearchResponse:
-
-    async def _search_solution_inner(cat: ReqGroupingCategory):
-        # process requirements into insight finder format
-        fmt_completion = await llm_router.acompletion("gemini-v2", messages=[
-            {
-                "role": "user",
-                "content": await prompt_env.get_template("if/format_requirements.txt").render_async(**{
-                    "category": cat.model_dump(),
-                    "response_schema": InsightFinderConstraintsList.model_json_schema()
-                })
-            }], response_format=InsightFinderConstraintsList)
-
-        fmt_model = InsightFinderConstraintsList.model_validate_json(
-            fmt_completion.choices[0].message.content)
-
-        # translate from a structured output to a dict for insights finder
-        formatted_constraints = {'constraints': {
-            cons.title: cons.description for cons in fmt_model.constraints}}
-
-        # fetch technologies from insight finder
-        technologies_req = await http_client.post(INSIGHT_FINDER_BASE_URL + "process-constraints", content=json.dumps(formatted_constraints))
-        technologies = TechnologyData.model_validate(technologies_req.json())
-
-        # =============================================================== synthesize solution using LLM =========================================
-
-        format_solution = await llm_router.acompletion("gemini-v2", messages=[{
-            "role": "user",
-            "content": await prompt_env.get_template("if/synthesize_solution.txt").render_async(**{
-                "category": cat.model_dump(),
-                "technologies": technologies.model_dump()["technologies"],
-                "user_constraints": req.user_constraints,
-                "response_schema": _SearchedSolutionModel.model_json_schema()
-            })}
-        ], response_format=_SearchedSolutionModel)
-
-        format_solution_model = _SearchedSolutionModel.model_validate_json(
-            format_solution.choices[0].message.content)
-
-        final_solution = SolutionModel(
-            Context="",
-            Requirements=[
-                cat.requirements[i].requirement for i in format_solution_model.requirement_ids
-            ],
-            Problem_Description=format_solution_model.problem_description,
-            Solution_Description=format_solution_model.solution_description,
-            References=[],
-            Category_Id=cat.id,
-        )
-
-        # ========================================================================================================================================
-
-        return final_solution
-
-    tasks = await asyncio.gather(*[_search_solution_inner(cat) for cat in req.categories], return_exceptions=True)
-    final_solutions = [sol for sol in tasks if not isinstance(sol, Exception)]
-
-    return SolutionSearchResponse(solutions=final_solutions)

prompts/search_solution.txt

@@ -1,23 +0,0 @@
-<role>You are an expert system designer</role>
-<task>
-Your task is to create a solution that should cover the maximum possible of requirements at once.
-The solution should be composed of multiple mechanisms, that are defined as processes, methods, or sequences of steps using a technology that explain how something works or achieves its requirements.
-You may for that search mechanisms for the different requirements.
-**Please actually make searches and do not simulate them.**
-
-You must aim for the following goals:
-    - The solution must aim to maximize requirement satisfaction while respecting the context.
-    - Provide a list of requirements addressed by the solution (provide only the requirement IDs)
-    - Please also detail each mechanism and how they work in the final solution description.
-    - Please describe the solution description using markdown in a consistent format.
-</task>
-
-Here is the category item and the associated requirements:
-<requirements>
-Category Title: {{category["title"]}}
-Context: {{category["requirements"][0]["context"]}}
-Requirements:
-{% for req in category["requirements"] -%}
-- {{loop.index0}} {{req["requirement"]}}
-{% endfor -%}
-</requirements>

prompts/search_solution_v2.txt

@@ -1,31 +0,0 @@
-<role>You are an expert system designer</role>
-<task>
-Your task is to create a solution that should cover the maximum possible of requirements at once.
-The solution should be composed of multiple mechanisms, that are defined as processes, methods, or sequences of steps using a technology that explain how something works or achieves its requirements.
-You may for that search mechanisms for the different requirements.
-
-**Please actually make searches and do not simulate them.**
-
-You must aim for the following goals:
-- The solution must aim to maximize requirement satisfaction while respecting the context.
-- Provide a list of requirements addressed by the solution (provide only the requirement IDs)
-- Please also detail each mechanism and how they work in the final solution description.
-- Please describe the solution description using markdown in a consistent format.
-</task>
-
-Here is the category item and the associated requirements:
-<requirements>
-Category Title: {{category["title"]}}
-Context: {{category["requirements"][0]["context"]}}
-Requirements:
-{% for req in category["requirements"] -%}
-- {{loop.index0}} {{req["requirement"]}}
-{% endfor -%}
-</requirements>
-
-{% if user_constraints is not none %}
-Here are additional user constraints the solution must respect:
-<user_constraints>
-    {{user_constraints}}
-</user_constraints> 
-{% endif %}

static/index.html

@@ -270,7 +270,7 @@
                         Categorize
                     </button>
                 </div>
-                <div class="flex flex-wrap justify-end items-center gap-6">
+                <!-- <div class="flex flex-wrap justify-end items-center gap-6">
                     <div class="tooltip" data-tip="Use Insight Finder's API to generate solutions">
                         <label class="label">
                             <span class="label-text text-base-content">Use insight finder solver</span>
@@ -278,7 +278,7 @@
                         <input type="checkbox" class="toggle toggle-primary" id="use-insight-finder-solver"
                             checked="false" />
                     </div>
-                </div>
+                </div> -->
             </div>
             <div id="categorized-requirements-container pt-10" class="mb-6">
                 <div class="flex mb-4 pt-10">

static/js/script.js

@@ -335,13 +335,6 @@ async function extractRequirements() {
             }
         });
 
-
-        //     const response = await fetch('/generate_requirements/', {
-        //         method: 'POST',
-        //         headers: { 'Content-Type': 'application/json' },
-        //         body: req
-        //     });
-
         const data = response.data; // data in the SSE message contains the requirements response
         requirements = data.requirements;
         let req_id = 0;
@@ -1047,33 +1040,30 @@ function clearAllSolutions() {
     document.querySelectorAll('.solution-accordion').forEach(a => a.remove());
 }
 
-async function generateSolutionsV1(selected_categories, user_constraints = null, useIFSolver = false) {
+async function generateSolutions(selected_categories, user_constraints = null) {
     console.log(selected_categories);
 
     let input_req = structuredClone(selected_categories);
     input_req.user_constraints = user_constraints;
-    console.log(useIFSolver);
-
-    const base_url = useIFSolver ? "/solutions/search_solutions_if" : "/solutions/search_solutions_gemini/v2"
 
-    let response = await fetch(base_url, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(input_req) })
+    let response = await fetch("/solutions/search_solutions", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(input_req) })
     let responseObj = await response.json()
     return responseObj;
 }
 
-async function generateCriticismsV1(solutions) {
+async function generateCriticisms(solutions) {
     let response = await fetch('/solutions/criticize_solution', { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(solutions) })
     let responseObj = await response.json()
     solutionsCriticizedVersions.push(responseObj)
 }
 
-async function refineSolutionsV1(critiques) {
+async function refineSolutions(critiques) {
     let response = await fetch('/solutions/refine_solutions', { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(critiques) })
     let responseObj = await response.json()
-    await generateCriticismsV1(responseObj)
+    await generateCriticisms(responseObj)
 }
 
-async function workflow(steps = 1, useIFSolver = false) {
+async function workflow(steps = 1) {
     let soluce;
     showLoadingOverlay('Génération des solutions & critiques ....');
 
@@ -1093,11 +1083,11 @@ async function workflow(steps = 1, useIFSolver = false) {
         }
 
         if (solutionsCriticizedVersions.length == 0) {
-            soluce = await generateSolutionsV1(selected_requirements, user_constraints ? user_constraints : null, useIFSolver);
-            await generateCriticismsV1(soluce)
+            soluce = await generateSolutions(selected_requirements, user_constraints ? user_constraints : null);
+            await generateCriticisms(soluce)
         } else {
             let prevSoluce = solutionsCriticizedVersions[solutionsCriticizedVersions.length - 1];
-            await refineSolutionsV1(prevSoluce)
+            await refineSolutions(prevSoluce)
         }
     }
     hideLoadingOverlay();
@@ -1129,10 +1119,10 @@ document.addEventListener('DOMContentLoaded', function () {
     // Événements pour les boutons de solutions (à implémenter plus tard)
     document.getElementById('get-solutions-btn').addEventListener('click', () => {
         const n_steps = document.getElementById('solution-gen-nsteps').value;
-        workflow(n_steps, document.getElementById('use-insight-finder-solver').checked);
+        workflow(n_steps);
     });
-    document.getElementById('get-solutions-step-btn').addEventListener('click', () => {
-        workflow(1, document.getElementById('use-insight-finder-solver').checked);
+        document.getElementById('get-solutions-step-btn').addEventListener('click', () => {
+        workflow(1);
     });
 });