Add Antropic

main.py

@@ -13,6 +13,8 @@ from pathlib import Path
 from bs4 import BeautifulSoup
 from typing import Union, List
 import asyncio
+from anthropic import Anthropic
+from openai import OpenAI
 from llama_index.core import (
     StorageContext,
     ServiceContext,
@@ -115,60 +117,159 @@ state_lp_json = gr.State()
 state_nodes = gr.State()
 
 
-class PrecedentAnalysisWorkflow(Workflow):
-    @step
-    async def analyze(self, ctx: Context, ev: StartEvent) -> StopEvent:
-        query = ev.get("query")  # нове рішення
-        question = ev.get("question")  # уточнююче питання
-        nodes = ev.get("nodes")  # знайдені правові позиції
+from enum import Enum
+
 
-        if not all([query, nodes]):
-            return StopEvent(result="Недостатньо даних для аналізу. Необхідні нове рішення та правові позиції.")
+class ModelProvider(str, Enum):
+    OPENAI = "openai"
+    ANTHROPIC = "anthropic"
 
-        llm_analyse = OpenAI(model="gpt-4o", temperature=0)
-        # llm_analyse = OpenAI(model="gpt-4o-mini", temperature=0)
 
-        # Підготовка контексту та збір ID правових позицій
-        context_parts = []
+class ModelName(str, Enum):
+    # OpenAI models
+    GPT4 = "gpt-4"
+    GPT4_TURBO = "gpt-4-turbo-preview"
+    GPT4_MINI = "gpt-4o-mini"
+    # Anthropic models
+    CLAUDE3_SONNET = "claude-3-sonnet-20240229"
+    CLAUDE3_OPUS = "claude-3-opus-20240229"
+    CLAUDE3_HAIKU = "claude-3-haiku-20240307"
 
-        for i, node in enumerate(nodes, 1):
-            # Отримуємо текст з node.node якщо це NodeWithScore
-            node_text = node.node.text if hasattr(node, 'node') else node.text
-            # Отримуємо metadata з node.node якщо це NodeWithScore
-            metadata = node.node.metadata if hasattr(node, 'node') else node.metadata
 
-            lp_id = metadata.get('lp_id', f'unknown_{i}')
-            source_index = str(i)
+class LLMAnalyzer:
+    def __init__(self, provider: ModelProvider, model_name: ModelName):
+        self.provider = provider
+        self.model_name = model_name
 
-            context_parts.append(f"Source {source_index} (ID: {lp_id}):\n{node_text}")
+        if provider == ModelProvider.OPENAI:
+            self.client = OpenAI(model=model_name)  # Використовуємо LlamaOpenAI
+        elif provider == ModelProvider.ANTHROPIC:
+            self.client = Anthropic()
+        else:
+            raise ValueError(f"Unsupported provider: {provider}")
 
-        context_str = "\n\n".join(context_parts)
+    async def analyze(self, prompt: str, response_schema: dict) -> str:
+        if self.provider == ModelProvider.OPENAI:
+            return await self._analyze_with_openai(prompt, response_schema)
+        else:
+            return await self._analyze_with_anthropic(prompt, response_schema)
+
+    async def _analyze_with_openai(self, prompt: str, response_schema: dict) -> str:
+        messages = [
+            ChatMessage(role="system",
+                        content="Ти - кваліфікований юрист-аналітик, експерт з правових позицій Верховного Суду."),
+            ChatMessage(role="user", content=prompt)
+        ]
 
+        # Правильний формат для response_format
         response_format = {
             "type": "json_schema",
             "json_schema": {
-                "name": "relevant_positions_schema",
-                "schema": {
-                    "type": "object",
-                    "properties": {
-                        "relevant_positions": {
-                            "type": "array",
-                            "items": {
-                                "type": "object",
-                                "properties": {
-                                    "lp_id": {"type": "string"},
-                                    "source_index": {"type": "string"},
-                                    "description": {"type": "string"}
-                                },
-                                "required": ["lp_id", "source_index", "description"]
-                            }
-                        }
-                    },
-                    "required": ["relevant_positions"]
-                }
+                "name": "relevant_positions_schema",  # Додаємо обов'язкове поле name
+                "schema": response_schema
             }
         }
 
+        response = self.client.chat(
+            messages=messages,
+            response_format=response_format,
+            temperature=0
+        )
+        return response.message.content
+
+    async def _analyze_with_anthropic(self, prompt: str, response_schema: dict) -> str:
+        response = await self.client.messages.create(
+            model=self.model_name,
+            temperature=0,
+            system="Ти - кваліфікований юрист-аналітик, експерт з правових позицій Верховного Суду.",
+            messages=[{"role": "user", "content": prompt}],
+            response_format={"type": "json_schema", "schema": response_schema}
+        )
+        return response.content[0].text
+
+
+class PrecedentAnalysisWorkflow(Workflow):
+    def __init__(self, provider: ModelProvider = ModelProvider.OPENAI,
+                 model_name: ModelName = ModelName.GPT4_MINI):
+        super().__init__()
+        self.analyzer = LLMAnalyzer(provider, model_name)
+
+    @step
+    async def analyze(self, ctx: Context, ev: StartEvent) -> StopEvent:
+        try:
+            # Отримуємо параметри з події з дефолтними значеннями
+            query = ev.get("query", "")
+            question = ev.get("question", "")
+            nodes = ev.get("nodes", [])
+
+            # Перевірка на пусті значення
+            if not query:
+                return StopEvent(result="Помилка: Не надано текст нового рішення (query)")
+
+            if not nodes:
+                return StopEvent(result="Помилка: Не надано правові позиції для аналізу (nodes)")
+
+            # Підготовка контексту
+            context_parts = []
+            for i, node in enumerate(nodes, 1):
+                node_text = node.node.text if hasattr(node, 'node') else node.text
+                metadata = node.node.metadata if hasattr(node, 'node') else node.metadata
+                lp_id = metadata.get('lp_id', f'unknown_{i}')
+                context_parts.append(f"Source {i} (ID: {lp_id}):\n{node_text}")
+
+            context_str = "\n\n".join(context_parts)
+
+            # Схема відповіді
+            response_schema = {
+                "type": "object",
+                "properties": {
+                    "relevant_positions": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "lp_id": {"type": "string"},
+                                "source_index": {"type": "string"},
+                                "description": {"type": "string"}
+                            },
+                            "required": ["lp_id", "source_index", "description"]
+                        }
+                    }
+                },
+                "required": ["relevant_positions"]
+            }
+
+            # Формування промпту
+            prompt = PRECEDENT_ANALYSIS_TEMPLATE.format(
+                query=query,
+                question=question if question else "Загальний аналіз релевантності",
+                context_str=context_str
+            )
+
+            # Отримання відповіді від моделі
+            response_content = await self.analyzer.analyze(prompt, response_schema)
+
+            try:
+                parsed_response = json.loads(response_content)
+                if "relevant_positions" in parsed_response:
+                    response_lines = []
+                    for position in parsed_response["relevant_positions"]:
+                        position_text = (
+                            f"* [{position['source_index']}] {position['description']}  "
+                        )
+                        response_lines.append(position_text)
+
+                    response_text = "\n".join(response_lines)
+                    return StopEvent(result=response_text)
+                else:
+                    return StopEvent(result="Не знайдено релевантних правових позицій")
+
+            except json.JSONDecodeError:
+                return StopEvent(result="Помилка обробки відповіді від AI")
+
+        except Exception as e:
+            return StopEvent(result=f"Error during analysis: {str(e)}")
+
         # Формування промпту та отримання відповіді
         prompt = PRECEDENT_ANALYSIS_TEMPLATE.format(
             query=query,
@@ -446,10 +547,19 @@ def create_gradio_interface():
             except Exception as e:
                 return f"Error during search: {str(e)}", None
 
-
         async def analyze_action(legal_position_json, question, nodes):
             try:
-                workflow = PrecedentAnalysisWorkflow(timeout=600)
+                # Використання з 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 = (

requirements.txt

@@ -3,6 +3,7 @@ llama-index-readers-file
 llama-index-vector-stores-faiss
 llama-index-retrievers-bm25
 openai
+anthropic
 faiss-cpu
 llama-index-embeddings-openai
 llama-index-llms-openai