Add Antropic

main.py

@@ -45,6 +45,7 @@ load_dotenv()
 aws_access_key_id = os.getenv("AWS_ACCESS_KEY_ID")
 aws_secret_access_key = os.getenv("AWS_SECRET_ACCESS_KEY")
 openai_api_key = os.getenv("OPENAI_API_KEY")
+anthropic_api_key=os.getenv("ANTHROPIC_API_KEY")
 
 embed_model = OpenAIEmbedding(model_name="text-embedding-3-small")
 Settings.embed_model = embed_model
@@ -127,13 +128,11 @@ class ModelProvider(str, Enum):
 
 class ModelName(str, Enum):
     # OpenAI models
-    GPT4 = "gpt-4"
-    GPT4_TURBO = "gpt-4-turbo-preview"
-    GPT4_MINI = "gpt-4o-mini"
+    GPT4o = "gpt-4o"
+    GPT4o_MINI = "gpt-4o-mini"
     # Anthropic models
-    CLAUDE3_SONNET = "claude-3-sonnet-20240229"
-    CLAUDE3_OPUS = "claude-3-opus-20240229"
-    CLAUDE3_HAIKU = "claude-3-haiku-20240307"
+    CLAUDE3_5_SONNET = "claude-3-5-sonnet-latest"
+    CLAUDE3_5_HAIKU = "claude-3-5-haiku-latest"
 
 
 class LLMAnalyzer:
@@ -142,9 +141,10 @@ class LLMAnalyzer:
         self.model_name = model_name
 
         if provider == ModelProvider.OPENAI:
-            self.client = OpenAI(model=model_name)  # Використовуємо LlamaOpenAI
+            self.client = OpenAI(model=model_name)
         elif provider == ModelProvider.ANTHROPIC:
-            self.client = Anthropic()
+            # Додаємо API ключ при ініціалізації
+            self.client = Anthropic(api_key=anthropic_api_key)
         else:
             raise ValueError(f"Unsupported provider: {provider}")
 
@@ -178,19 +178,26 @@ class LLMAnalyzer:
         return response.message.content
 
     async def _analyze_with_anthropic(self, prompt: str, response_schema: dict) -> str:
-        response = await self.client.messages.create(
+        response = self.client.messages.create(  # Прибрали await
             model=self.model_name,
-            temperature=0,
-            system="Ти - кваліфікований юрист-аналітик, експерт з правових позицій Верховного Суду.",
-            messages=[{"role": "user", "content": prompt}],
-            response_format={"type": "json_schema", "schema": response_schema}
+            max_tokens=2000,
+            messages=[
+                {
+                    "role": "assistant",
+                    "content": "Ти - кваліфікований юрист-аналітик, експерт з правових позицій Верховного Суду."
+                },
+                {
+                    "role": "user",
+                    "content": prompt
+                }
+            ]
         )
         return response.content[0].text
 
 
 class PrecedentAnalysisWorkflow(Workflow):
     def __init__(self, provider: ModelProvider = ModelProvider.OPENAI,
-                 model_name: ModelName = ModelName.GPT4_MINI):
+                 model_name: ModelName = ModelName.GPT4o_MINI):
         super().__init__()
         self.analyzer = LLMAnalyzer(provider, model_name)
 
@@ -482,139 +489,291 @@ def generate_legal_position(court_decision_text, user_question):
         }
 
 
+# def create_gradio_interface():
+#     with gr.Blocks() as app:
+#         gr.Markdown("# Аналізатор релевантних Правових Позицій Верховного Суду для нового судового рішення")
+#
+#         with gr.Row():
+#             url_input = gr.Textbox(label="URL судового рішення:")
+#             question_input = gr.Textbox(label="Уточнююче питання для аналізу:")
+#
+#         with gr.Row():
+#             generate_position_button = gr.Button("Генерувати короткий зміст позиції суду")
+#             search_with_ai_button = gr.Button("Пошук із ШІ", interactive=False)
+#             # search_without_ai_button = gr.Button("Пошук без ШІ")
+#             analyze_button = gr.Button("Аналіз", interactive=False)
+#
+#         position_output = gr.Markdown(label="Короткий зміст позиції суду за введеним рішенням")
+#         search_output = gr.Markdown(label="Результат пошуку")
+#         analysis_output = gr.Markdown(label="Результат аналізу")
+#
+#         # Два об'єкти стану для зберігання legal_position_json та nodes
+#         state_lp_json = gr.State()
+#         state_nodes = gr.State()
+#
+#         async def generate_position_action(url):
+#             try:
+#                 court_decision_text = extract_court_decision_text(url)
+#                 legal_position_json = generate_legal_position(court_decision_text, "")
+#                 position_output_content = f"**Короткий зміст позиції суду за введеним рішенням:**\n *{legal_position_json['title']}*: \n{legal_position_json['text']} **Категорія:** \n{legal_position_json['category']} ({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 search_with_ai_action(legal_position_json):
+#             try:
+#                 query_text = legal_position_json["title"] + ': ' + legal_position_json["text"] + ': ' + legal_position_json["proceeding"] + ': ' + legal_position_json["category"]
+#                 nodes = await retriever_bm25.aretrieve(query_text)
+#
+#                 sources_output = "\n **Результати пошуку (наявні правові позиції ВСУ):** \n\n"
+#                 for index, node in enumerate(nodes, start=1):
+#                     source_title = node.node.metadata.get('title')
+#                     doc_ids = node.node.metadata.get('doc_id')
+#                     lp_ids = node.node.metadata.get('lp_id')
+#                     links = get_links_html(doc_ids)
+#                     links_lp = get_links_html_lp(lp_ids)
+#                     sources_output += f"\n[{index}] *{source_title}* {links_lp} 👉 Score: {node.score} {links}\n"
+#
+#                 return sources_output, nodes
+#             except Exception as e:
+#                 return f"Error during search: {str(e)}", None
+#
+#         async def search_without_ai_action(url):
+#             try:
+#                 court_decision_text = extract_court_decision_text(url)
+#                 nodes = await retriever_bm25.aretrieve(court_decision_text)
+#
+#                 search_output_content = f"**Результати пошуку (наявні правові позиції ВСУ):** \n\n"
+#                 for index, node in enumerate(nodes, start=1):
+#                     source_title = node.node.metadata.get('title', 'Невідомий заголовок')
+#                     doc_ids = node.node.metadata.get('doc_id')
+#                     links = get_links_html(doc_ids)
+#                     search_output_content += f"\n[{index}] *{source_title}* 👉 Score: {node.score} {links}\n"
+#
+#                 return search_output_content, nodes
+#             except Exception as e:
+#                 return f"Error during search: {str(e)}", None
+#
+#         async def analyze_action(legal_position_json, question, nodes):
+#             try:
+#                 # Використання з OpenAI
+#                 workflow = PrecedentAnalysisWorkflow(
+#                     provider=ModelProvider.OPENAI,
+#                     model_name=ModelName.GPT4_MINI
+#                 )
+#
+#                 # # Використання з Anthropic
+#                 # workflow_anthropic = PrecedentAnalysisWorkflow(
+#                 #     provider=ModelProvider.ANTHROPIC,
+#                 #     model_name=ModelName.CLAUDE3_SONNET
+#                 # )
+#
+#                 # Формуємо єдиний текст запиту з legal_position_json
+#                 query = (
+#                     f"{legal_position_json['title']}: "
+#                     f"{legal_position_json['text']}: "
+#                     f"{legal_position_json['proceeding']}: "
+#                     f"{legal_position_json['category']}"
+#                 )
+#
+#                 # Запускаємо workflow і отримуємо текст аналізу
+#                 response_text = await workflow.run(
+#                     query=query,
+#                     question=question,
+#                     nodes=nodes
+#                 )
+#
+#                 # Формуємо вивід
+#                 output = f"**Аналіз ШІ:**\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(']')]  # Витягуємо індекс з "* [X]"
+#
+#                         # Знаходимо відповідний node за індексом
+#                         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
+#
+#             except Exception as e:
+#                 return f"Error during analysis: {str(e)}"
+#
+#         # Підключаємо функції до кнопок з оновленими входами та виходами
+#         generate_position_button.click(
+#             fn=generate_position_action,
+#             inputs=url_input,
+#             outputs=[position_output, state_lp_json]
+#         )
+#         generate_position_button.click(
+#             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]
+#         )
+#         search_with_ai_button.click(
+#             fn=lambda: gr.update(interactive=True),
+#             inputs=None,
+#             outputs=analyze_button
+#         )
+#
+#         # search_without_ai_button.click(
+#         #     fn=search_without_ai_action,
+#         #     inputs=url_input,
+#         #     outputs=[search_output, state_nodes]
+#         # )
+#         # search_without_ai_button.click(
+#         #     fn=lambda: gr.update(interactive=True),
+#         #     inputs=None,
+#         #     outputs=analyze_button
+#         # )
+#
+#         analyze_button.click(
+#             fn=analyze_action,
+#             inputs=[state_lp_json, question_input, state_nodes],
+#             outputs=analysis_output
+#         )
+#
+#     return app
+
 def create_gradio_interface():
+    async def generate_position_action(url):
+        try:
+            court_decision_text = extract_court_decision_text(url)
+            legal_position_json = generate_legal_position(court_decision_text, "")
+            position_output_content = f"**Короткий зміст позиції суду за введеним рішенням:**\n *{legal_position_json['title']}*: \n{legal_position_json['text']} **Категорія:** \n{legal_position_json['category']} ({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 search_with_ai_action(legal_position_json):
+        try:
+            query_text = legal_position_json["title"] + ': ' + legal_position_json["text"] + ': ' + legal_position_json["proceeding"] + ': ' + legal_position_json["category"]
+            nodes = await retriever_bm25.aretrieve(query_text)
+
+            sources_output = "\n **Результати пошуку (наявні правові позиції ВСУ):** \n\n"
+            for index, node in enumerate(nodes, start=1):
+                source_title = node.node.metadata.get('title')
+                doc_ids = node.node.metadata.get('doc_id')
+                lp_ids = node.node.metadata.get('lp_id')
+                links = get_links_html(doc_ids)
+                links_lp = get_links_html_lp(lp_ids)
+                sources_output += f"\n[{index}] *{source_title}* {links_lp} 👉 Score: {node.score} {links}\n"
+
+            return sources_output, nodes
+        except Exception as e:
+            return f"Error during search: {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
+
+        except Exception as e:
+            return f"Error during analysis: {str(e)}"
+
+    def update_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")])
+
     with gr.Blocks() as app:
+        # Далі ваш код інтерфейсу...
         gr.Markdown("# Аналізатор релевантних Правових Позицій Верховного Суду для нового судового рішення")
 
         with gr.Row():
             url_input = gr.Textbox(label="URL судового рішення:")
             question_input = gr.Textbox(label="Уточнююче питання для аналізу:")
 
+        with gr.Row():
+            provider_dropdown = gr.Dropdown(
+                choices=[p.value for p in ModelProvider],
+                value=ModelProvider.OPENAI.value,
+                label="Провайдер AI",
+            )
+            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)
-            # search_without_ai_button = gr.Button("Пошук без ШІ")
             analyze_button = gr.Button("Аналіз", interactive=False)
 
         position_output = gr.Markdown(label="Короткий зміст позиції суду за введеним рішенням")
         search_output = gr.Markdown(label="Результат пошуку")
         analysis_output = gr.Markdown(label="Результат аналізу")
 
-        # Два об'єкти стану для зберігання legal_position_json та nodes
         state_lp_json = gr.State()
         state_nodes = gr.State()
 
-        async def generate_position_action(url):
-            try:
-                court_decision_text = extract_court_decision_text(url)
-                legal_position_json = generate_legal_position(court_decision_text, "")
-                position_output_content = f"**Короткий зміст позиції суду за введеним рішенням:**\n *{legal_position_json['title']}*: \n{legal_position_json['text']} **Категорія:** \n{legal_position_json['category']} ({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 search_with_ai_action(legal_position_json):
-            try:
-                query_text = legal_position_json["title"] + ': ' + legal_position_json["text"] + ': ' + legal_position_json["proceeding"] + ': ' + legal_position_json["category"]
-                nodes = await retriever_bm25.aretrieve(query_text)
-
-                sources_output = "\n **Результати пошуку (наявні правові позиції ВСУ):** \n\n"
-                for index, node in enumerate(nodes, start=1):
-                    source_title = node.node.metadata.get('title')
-                    doc_ids = node.node.metadata.get('doc_id')
-                    lp_ids = node.node.metadata.get('lp_id')
-                    links = get_links_html(doc_ids)
-                    links_lp = get_links_html_lp(lp_ids)
-                    sources_output += f"\n[{index}] *{source_title}* {links_lp} 👉 Score: {node.score} {links}\n"
-
-                return sources_output, nodes
-            except Exception as e:
-                return f"Error during search: {str(e)}", None
-
-        async def search_without_ai_action(url):
-            try:
-                court_decision_text = extract_court_decision_text(url)
-                nodes = await retriever_bm25.aretrieve(court_decision_text)
-
-                search_output_content = f"**Результати пошуку (наявні правові позиції ВСУ):** \n\n"
-                for index, node in enumerate(nodes, start=1):
-                    source_title = node.node.metadata.get('title', 'Невідомий заголовок')
-                    doc_ids = node.node.metadata.get('doc_id')
-                    links = get_links_html(doc_ids)
-                    search_output_content += f"\n[{index}] *{source_title}* 👉 Score: {node.score} {links}\n"
-
-                return search_output_content, nodes
-            except Exception as e:
-                return f"Error during search: {str(e)}", None
-
-        async def analyze_action(legal_position_json, question, nodes):
-            try:
-                # Використання з OpenAI
-                workflow = PrecedentAnalysisWorkflow(
-                    provider=ModelProvider.OPENAI,
-                    model_name=ModelName.GPT4_MINI
-                )
-
-                # # Використання з Anthropic
-                # workflow_anthropic = PrecedentAnalysisWorkflow(
-                #     provider=ModelProvider.ANTHROPIC,
-                #     model_name=ModelName.CLAUDE3_SONNET
-                # )
-
-                # Формуємо єдиний текст запиту з legal_position_json
-                query = (
-                    f"{legal_position_json['title']}: "
-                    f"{legal_position_json['text']}: "
-                    f"{legal_position_json['proceeding']}: "
-                    f"{legal_position_json['category']}"
-                )
-
-                # Запускаємо workflow і отримуємо текст аналізу
-                response_text = await workflow.run(
-                    query=query,
-                    question=question,
-                    nodes=nodes
-                )
-
-                # Формуємо вивід
-                output = f"**Аналіз ШІ:**\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(']')]  # Витягуємо індекс з "* [X]"
-
-                        # Знаходимо відповідний node за індексом
-                        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
-
-            except Exception as e:
-                return f"Error during analysis: {str(e)}"
-
-        # Підключаємо функції до кнопок з оновленими входами та виходами
+        # Підключення функцій до кнопок
         generate_position_button.click(
             fn=generate_position_action,
             inputs=url_input,
             outputs=[position_output, state_lp_json]
-        )
-        generate_position_button.click(
+        ).then(
             fn=lambda: gr.update(interactive=True),
             inputs=None,
             outputs=search_with_ai_button
@@ -624,30 +783,24 @@ def create_gradio_interface():
             fn=search_with_ai_action,
             inputs=state_lp_json,
             outputs=[search_output, state_nodes]
-        )
-        search_with_ai_button.click(
+        ).then(
             fn=lambda: gr.update(interactive=True),
             inputs=None,
             outputs=analyze_button
         )
 
-        # search_without_ai_button.click(
-        #     fn=search_without_ai_action,
-        #     inputs=url_input,
-        #     outputs=[search_output, state_nodes]
-        # )
-        # search_without_ai_button.click(
-        #     fn=lambda: gr.update(interactive=True),
-        #     inputs=None,
-        #     outputs=analyze_button
-        # )
-
         analyze_button.click(
             fn=analyze_action,
-            inputs=[state_lp_json, question_input, state_nodes],
+            inputs=[state_lp_json, question_input, state_nodes, provider_dropdown, model_dropdown],
             outputs=analysis_output
         )
 
+        provider_dropdown.change(
+            fn=update_model_choices,
+            inputs=provider_dropdown,
+            outputs=model_dropdown
+        )
+
     return app
 
 if __name__ == "__main__":