Edit for Beneficiar

generation.py

@@ -1,42 +1,31 @@
 import json
 from enum import Enum
 from openai import OpenAI
+from anthropic import Anthropic
 import google.generativeai as genai
 from llama_index.core.llms import ChatMessage
 from prompts import LEGAL_POSITION_PROMPT, SYSTEM_PROMPT
+from config import anthropic_api_key
 
 
 class GenerationProvider(str, Enum):
     OPENAI = "openai"
-    GEMINI = "gemini"
+    # GEMINI = "gemini"
+    ANTHROPIC = "anthropic"
 
 
 class GenerationModelName(str, Enum):
     # OpenAI models
-    GPT4_LEGAL = "ft:gpt-4o-mini-2024-07-18:personal:legal-position-1500:Aaiu4WZd"
+    GPT_MODEL_8 = "ft:gpt-4o-mini-2024-07-18:personal:legal-position-1500:Aaiu4WZd"
+    GPT_MODEL_9 = "ft:gpt-4o-mini-2024-07-18:personal:legal-position-1700:AbNt5I2x"
+
     # Gemini models
-    GEMINI_FLASH = "gemini-1.5-flash"
-
-
-# Schema for OpenAI response
-LEGAL_POSITION_SCHEMA = {
-    "type": "json_schema",
-    "json_schema": {
-        "name": "lp_schema",
-        "schema": {
-            "type": "object",
-            "properties": {
-                "title": {"type": "string", "description": "Title of the legal position"},
-                "text": {"type": "string", "description": "Text of the legal position"},
-                "proceeding": {"type": "string", "description": "Type of court proceedings"},
-                "category": {"type": "string", "description": "Category of the legal position"},
-            },
-            "required": ["title", "text", "proceeding", "category"],
-            "additionalProperties": False
-        },
-        "strict": True
-    }
-}
+    # GEMINI_FLASH = "gemini-1.5-flash"
+
+    # Anthropic models
+    # CLAUDE_3_HAIKU = "claude-3-haiku-20240307"
+    ANTHROPIC_MODEL_4 = "claude-3-5-sonnet-latest"
+    # CLAUDE_3_OPUS = "claude-3-opus-20240229"
 
 
 def generate_legal_position(court_decision_text: str, comment_input: str, provider: str, model_name: str) -> dict:
@@ -67,34 +56,65 @@ def generate_legal_position(court_decision_text: str, comment_input: str, provid
             )
             parsed_response = json.loads(response.choices[0].message.content)
 
-            # Перевірка та конвертація полів
-            if 'text_lp' in parsed_response and 'text' not in parsed_response:
-                parsed_response['text'] = parsed_response.pop('text_lp')
-
-        elif provider == GenerationProvider.GEMINI.value:
-            generation_config = {
-                "temperature": 0,
-                "max_output_tokens": 8192,
-                "response_mime_type": "application/json",
+        # elif provider == GenerationProvider.GEMINI.value:
+        #     generation_config = {
+        #         "temperature": 0,
+        #         "max_output_tokens": 8192,
+        #         "response_mime_type": "application/json",
+        #     }
+        #
+        #     model = genai.GenerativeModel(
+        #         model_name=model_name,
+        #         generation_config=generation_config,
+        #     )
+        #
+        #     chat = model.start_chat(history=[])
+        #     response = chat.send_message(
+        #         f"{SYSTEM_PROMPT}\n\n{content}",
+        #     )
+        #     parsed_response = json.loads(response.text)
+
+        elif provider == GenerationProvider.ANTHROPIC.value:
+            client = Anthropic(api_key=anthropic_api_key)
+
+            json_instruction = """
+            Будь ласка, надай відповідь у форматі JSON з наступними полями:
+            {
+                "title": "заголовок правової позиції",
+                "text": "текст правової позиції",
+                "proceeding": "тип судочинства",
+                "category": "категорія справи"
             }
+            """
 
-            model = genai.GenerativeModel(
-                model_name=model_name,
-                generation_config=generation_config,
-            )
-
-            chat = model.start_chat(history=[])
-            response = chat.send_message(
-                f"{SYSTEM_PROMPT}\n\n{content}",
+            response = client.messages.create(
+                model=model_name,
+                max_tokens=4096,
+                temperature=0,
+                messages=[
+                    {
+                        "role": "assistant",
+                        "content": "Ти - кваліфікований юрист-аналітик."
+                    },
+                    {
+                        "role": "user",
+                        "content": f"{SYSTEM_PROMPT}\n{json_instruction}\n{content}"
+                    }
+                ]
             )
-            parsed_response = json.loads(response.text)
-
-            # Та сама перевірка для Gemini
-            if 'text_lp' in parsed_response and 'text' not in parsed_response:
-                parsed_response['text'] = parsed_response.pop('text_lp')
+            parsed_response = json.loads(response.content[0].text)
 
         else:
-            raise ValueError(f"Unsupported provider: {provider}")
+            return {
+                "title": "Error",
+                "text": f"Unsupported provider: {provider}",
+                "proceeding": "Error",
+                "category": "Error"
+            }
+
+        # Перевірка та конвертація полів для всіх провайдерів
+        if 'text_lp' in parsed_response and 'text' not in parsed_response:
+            parsed_response['text'] = parsed_response.pop('text_lp')
 
         # Валідація результату
         required_fields = ["title", "text", "proceeding", "category"]
@@ -102,7 +122,12 @@ def generate_legal_position(court_decision_text: str, comment_input: str, provid
             return parsed_response
 
         missing_fields = [field for field in required_fields if field not in parsed_response]
-        raise ValueError(f"Missing required fields: {', '.join(missing_fields)}")
+        return {
+            "title": parsed_response.get('title', 'Error'),
+            "text": f"Missing required fields: {', '.join(missing_fields)}",
+            "proceeding": parsed_response.get('proceeding', 'Error'),
+            "category": parsed_response.get('category', 'Error')
+        }
 
     except json.JSONDecodeError as e:
         return {
@@ -113,8 +138,8 @@ def generate_legal_position(court_decision_text: str, comment_input: str, provid
         }
     except Exception as e:
         return {
-            "title": str(parsed_response.get('title', 'Error')),
-            "text": str(parsed_response.get('text_lp', parsed_response.get('text', str(e)))),
-            "proceeding": str(parsed_response.get('proceeding', 'Error')),
-            "category": str(parsed_response.get('category', 'Error'))
+            "title": "Error",
+            "text": f"Unexpected error: {str(e)}",
+            "proceeding": "Error",
+            "category": "Error"
         }

interface.py

@@ -1,171 +1,76 @@
 import gradio as gr
 from typing import List
 import json
-from enum import Enum
 
-from analysis import ModelProvider, ModelName, PrecedentAnalysisWorkflow
 from generation import GenerationProvider, GenerationModelName, generate_legal_position
-from utils import extract_court_decision_text, get_links_html, get_links_html_lp
-from search import search_with_ai_action
+from utils import extract_court_decision_text
 
 
 def create_gradio_interface():
     def update_generation_model_choices(provider):
         if provider == GenerationProvider.OPENAI.value:
             return gr.Dropdown(choices=[m.value for m in GenerationModelName if m.value.startswith("ft")])
-        else:
-            return gr.Dropdown(choices=[m.value for m in GenerationModelName if m.value.startswith("gemini")])
+        # elif provider == GenerationProvider.GEMINI.value:
+        #     return gr.Dropdown(choices=[m.value for m in GenerationModelName if m.value.startswith("gemini")])
+        elif provider == GenerationProvider.ANTHROPIC.value:
+            return gr.Dropdown(choices=[m.value for m in GenerationModelName if m.value.startswith("claude")])
 
-    def update_analysis_model_choices(provider):
-        if provider == ModelProvider.OPENAI.value:
-            return gr.Dropdown(choices=[m.value for m in ModelName if m.value.startswith("gpt")])
-        else:
-            return gr.Dropdown(choices=[m.value for m in ModelName if m.value.startswith("claude")])
+    def get_model_name_by_value(model_value: str) -> str:
+        try:
+            # Знаходимо відповідну модель в енумі за значенням
+            model = next(model for model in GenerationModelName if model.value == model_value)
+            return model.name
+        except StopIteration:
+            return model_value
 
-    async def generate_position_action(url, provider, model_name, comment_input):
+    async def generate_position_action(url, provider, model_name):
         try:
             court_decision_text = extract_court_decision_text(url)
-            legal_position_json = generate_legal_position(court_decision_text, comment_input, provider, model_name)
+            legal_position_json = generate_legal_position(court_decision_text, "", provider, model_name)
+            display_model_name = get_model_name_by_value(model_name)
             position_output_content = (
-                f"**Короткий зміст позиції суду за введеним рішенням (модель: {model_name}):**\n"
+                f"**Короткий зміст позиції суду за введеним рішенням (модель: {display_model_name}):**\n"
                 f"*{legal_position_json['title']}*: \n"
                 f"{legal_position_json['text']} "
                 f"**Категорія:** \n{legal_position_json['category']} "
                 f"({legal_position_json['proceeding']})\n\n"
             )
-            return position_output_content, legal_position_json
-        except Exception as e:
-            return f"Error during position generation: {str(e)}", None
-
-    async def analyze_action(legal_position_json, question, nodes, provider, model_name):
-        try:
-            workflow = PrecedentAnalysisWorkflow(
-                provider=ModelProvider(provider),
-                model_name=ModelName(model_name)
-            )
-
-            query = (
-                f"{legal_position_json['title']}: "
-                f"{legal_position_json['text']}: "
-                f"{legal_position_json['proceeding']}: "
-                f"{legal_position_json['category']}"
-            )
-
-            response_text = await workflow.run(
-                query=query,
-                question=question,
-                nodes=nodes
-            )
-
-            output = f"**Аналіз ШІ (модель: {model_name}):**\n{response_text}\n\n"
-            output += "**Наявні в базі Правові Позицій Верховного Суду:**\n\n"
-
-            analysis_lines = response_text.split('\n')
-            for line in analysis_lines:
-                if line.startswith('* ['):
-                    index = line[3:line.index(']')]
-                    node = nodes[int(index) - 1]
-                    source_node = node.node
-
-                    source_title = source_node.metadata.get('title', 'Невідомий заголовок')
-                    source_text_lp = node.text
-                    doc_ids = source_node.metadata.get('doc_id')
-                    lp_id = source_node.metadata.get('lp_id')
-
-                    links = get_links_html(doc_ids)
-                    links_lp = get_links_html_lp(lp_id)
-
-                    output += f"[{index}]: *{source_title}* | {source_text_lp} | {links_lp} | {links}\n\n"
-
-            return output
-
+            return position_output_content
         except Exception as e:
-            return f"Error during analysis: {str(e)}"
+            return f"Error during position generation: {str(e)}"
 
     with gr.Blocks() as app:
-        gr.Markdown("# Аналізатор релевантних Правових Позицій Верховного Суду для нового судового рішення")
+        gr.Markdown("# Генератор короткого змісту судового рішення")
 
-        with gr.Row():
-            comment_input = gr.Textbox(label="Коментар до формування короткого змісту судового рішення:")
-            url_input = gr.Textbox(label="URL судового рішення:")
-            question_input = gr.Textbox(label="Уточнююче питання для аналізу:")
+        url_input = gr.Textbox(label="URL судового рішення:")
 
         with gr.Row():
-            # Провайдер для генерування
             generation_provider_dropdown = gr.Dropdown(
                 choices=[p.value for p in GenerationProvider],
-                value=GenerationProvider.GEMINI.value,
+                value=GenerationProvider.OPENAI.value,
                 label="Провайдер AI для генерування",
             )
             generation_model_dropdown = gr.Dropdown(
-                choices=[m.value for m in GenerationModelName if m.value.startswith("gemini")],
-                value=GenerationModelName.GEMINI_FLASH.value,
+                choices=[m.value for m in GenerationModelName if m.value.startswith("ft")],
+                value=GenerationModelName.GPT4_MODEL_9.value,
                 label="Модель для генерування",
             )
 
-        with gr.Row():
-            # Провайдер для аналізу
-            analysis_provider_dropdown = gr.Dropdown(
-                choices=[p.value for p in ModelProvider],
-                value=ModelProvider.OPENAI.value,
-                label="Провайдер AI для аналізу",
-            )
-            analysis_model_dropdown = gr.Dropdown(
-                choices=[m.value for m in ModelName if m.value.startswith("gpt")],
-                value=ModelName.GPT4o_MINI.value,
-                label="Модель для аналізу",
-            )
-
-        with gr.Row():
-            generate_position_button = gr.Button("Генерувати короткий зміст позиції суду")
-            search_with_ai_button = gr.Button("Пошук", interactive=False)
-            analyze_button = gr.Button("Аналіз", interactive=False)
-
+        generate_position_button = gr.Button("Генерувати короткий зміст позиції суду")
         position_output = gr.Markdown(label="Короткий зміст позиції суду за введеним рішенням")
-        search_output = gr.Markdown(label="Результат пошуку")
-        analysis_output = gr.Markdown(label="Результат аналізу")
-
-        state_lp_json = gr.State()
-        state_nodes = gr.State()
 
         # Підключення функцій до кнопок та подій
         generate_position_button.click(
             fn=generate_position_action,
-            inputs=[url_input, generation_provider_dropdown, generation_model_dropdown, comment_input],
-            outputs=[position_output, state_lp_json]
-        ).then(
-            fn=lambda: gr.update(interactive=True),
-            inputs=None,
-            outputs=search_with_ai_button
-        )
-
-        search_with_ai_button.click(
-            fn=search_with_ai_action,
-            inputs=state_lp_json,
-            outputs=[search_output, state_nodes]
-        ).then(
-            fn=lambda: gr.update(interactive=True),
-            inputs=None,
-            outputs=analyze_button
+            inputs=[url_input, generation_provider_dropdown, generation_model_dropdown],
+            outputs=position_output
         )
 
-        analyze_button.click(
-            fn=analyze_action,
-            inputs=[state_lp_json, question_input, state_nodes, analysis_provider_dropdown, analysis_model_dropdown],
-            outputs=analysis_output
-        )
-
-        # Оновлення списків моделей при зміні провайдера
+        # Оновлення списку моделей при зміні провайдера
         generation_provider_dropdown.change(
             fn=update_generation_model_choices,
             inputs=generation_provider_dropdown,
             outputs=generation_model_dropdown
         )
 
-        analysis_provider_dropdown.change(
-            fn=update_analysis_model_choices,
-            inputs=analysis_provider_dropdown,
-            outputs=analysis_model_dropdown
-        )
-
     return app