simplify

add_secrets.ipynb

@@ -32,17 +32,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "id": "90204225",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "git remote add hf https://huggingface.co/spaces/Cyberlgl/CyberLegalAIendpoint\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 3,
    "id": "ebc2564d",
    "metadata": {},
    "outputs": [

agent_api.py

@@ -60,7 +60,6 @@ class ChatRequest(BaseModel):
 
 class ChatResponse(BaseModel):
     response: str = Field(..., description="Assistant's response")
-    confidence: float = Field(..., description="Confidence score (0.0-1.0)")
     processing_time: float = Field(..., description="Processing time in seconds")
     references: List[str] = Field(default=[], description="Referenced documents")
     timestamp: str = Field(..., description="Response timestamp")
@@ -111,7 +110,6 @@ class CyberLegalAPI:
             # Create response
             response = ChatResponse(
                 response=result["response"],
-                confidence=result.get("confidence", 0.0),
                 processing_time=result.get("processing_time", 0.0),
                 references=result.get("references", []),
                 timestamp=result.get("timestamp", datetime.now().isoformat()),

agent_state.py

@@ -15,7 +15,6 @@ class AgentState(TypedDict):
     user_query: str
     conversation_history: List[Dict[str, str]]
     
-    # LightRAG integration
     lightrag_response: Optional[Dict[str, Any]]
     lightrag_error: Optional[str]
     
@@ -30,7 +29,6 @@ class AgentState(TypedDict):
     
     # Final output
     final_response: Optional[str]
-    confidence_score: Optional[float]
     
     # Metadata
     query_timestamp: str

langraph_agent.py

@@ -4,14 +4,18 @@ Simplified LangGraph agent implementation for cyber-legal assistant
 """
 
 import os
+import logging
 from typing import Dict, Any, List, Optional
 from datetime import datetime
 from langgraph.graph import StateGraph, END
 from langchain_openai import ChatOpenAI
 from langchain_core.messages import HumanMessage, SystemMessage, AIMessage
 
+# Configure logging
+logger = logging.getLogger(__name__)
+
 from agent_state import AgentState, ConversationManager
-from prompts import SYSTEM_PROMPT, ERROR_HANDLING_PROMPT
+from prompts import SYSTEM_PROMPT, ERROR_HANDLING_PROMPT, RESPONSE_FORMATTING_PROMPT
 from utils import LightRAGClient, ConversationFormatter, PerformanceMonitor
 
 
@@ -45,34 +49,14 @@ class CyberLegalAgent:
         # Add nodes
         workflow.add_node("query_lightrag", self._query_lightrag)
         workflow.add_node("answer_with_context", self._answer_with_context)
-        workflow.add_node("handle_error", self._handle_error)
         
         # Add edges
         workflow.set_entry_point("query_lightrag")
         workflow.add_edge("query_lightrag", "answer_with_context")
         workflow.add_edge("answer_with_context", END)
-        workflow.add_edge("handle_error", END)
-        
-        # Add conditional edges
-        workflow.add_conditional_edges(
-            "query_lightrag",
-            self._should_handle_error,
-            {
-                "error": "handle_error",
-                "continue": "answer_with_context"
-            }
-        )
         
         return workflow.compile()
     
-    def _should_handle_error(self, state: AgentState) -> str:
-        """
-        Determine if we should handle an error
-        """
-        if state.get("lightrag_error"):
-            return "error"
-        return "continue"
-    
     async def _query_lightrag(self, state: AgentState) -> AgentState:
         """
         Query LightRAG for legal information
@@ -80,10 +64,6 @@ class CyberLegalAgent:
         self.performance_monitor.start_timer("lightrag_query")
         
         try:
-            # Check LightRAG health
-            if not self.lightrag_client.health_check():
-                state["lightrag_error"] = "LightRAG server is not healthy"
-                return state
             
             # Prepare conversation history for LightRAG
             history = state.get("conversation_history", [])
@@ -91,21 +71,28 @@ class CyberLegalAgent:
             
             # Query LightRAG
             query = state["user_query"]
-            response = self.lightrag_client.query(
+            lightrag_response = self.lightrag_client.query(
                 query=query,
                 conversation_history=formatted_history
             )
             
-            if "error" in response:
-                state["lightrag_error"] = response["error"]
+            state["lightrag_response"] = lightrag_response
+            state["relevant_documents"] = self.lightrag_client.get_references(lightrag_response)
+            
+            # Log LightRAG response
+            lightrag_context = lightrag_response.get("response", "")
+            logger.info(f"🔍 LightRAG response received:")
+            logger.info(f"📄 Context length: {len(lightrag_context)} characters")
+            logger.info(f"📚 References found: {len(state.get('relevant_documents', []))}")
+            if len(lightrag_context) > 1500:
+                logger.info(f"📝 Context preview: {lightrag_context[:500]}...")
             else:
-                state["lightrag_response"] = response
-                state["relevant_documents"] = self.lightrag_client.get_references(response)
+                logger.info(f"📝 Full context: {lightrag_context}")
         
         except Exception as e:
-            state["lightrag_error"] = f"LightRAG query failed: {str(e)}"
-        
-        self.performance_monitor.end_timer("lightrag_query")
+            raise e
+        lightrag_duration = self.performance_monitor.end_timer("lightrag_query")
+        logger.info(f"⏱️  LightRAG query processing time: {lightrag_duration:.3f}s")
         return state
     
     async def _answer_with_context(self, state: AgentState) -> AgentState:
@@ -115,22 +102,10 @@ class CyberLegalAgent:
         self.performance_monitor.start_timer("answer_generation")
         
         try:
-            if not state.get("lightrag_response"):
-                state["lightrag_error"] = "No response from LightRAG"
-                return state
-            
-            # Extract context from LightRAG response
             lightrag_response = state["lightrag_response"]
             context = lightrag_response.get("response", "")
-            
-            if not context:
-                state["final_response"] = "I apologize, but I couldn't find relevant information for your query."
-                return state
-            
-            # Build message stack with conversation history
             messages = []
-            
-            # Add conversation history messages
+        
             history = state.get("conversation_history", [])
             has_system_message = False
             
@@ -143,49 +118,20 @@ class CyberLegalAgent:
                 elif msg["role"] == "assistant":
                     messages.append(AIMessage(content=msg["content"]))
             
-            # Add system message only if not present in history
             if not has_system_message:
                 messages.insert(0, SystemMessage(content=SYSTEM_PROMPT))
-            
-            # Add final message with user query and LightRAG context
-            answer_prompt = f"""Based on the following retrieved legal information, please answer the user's question accurately and comprehensively.
-
-**User Question:** {state["user_query"]}
-
-**Retrieved Legal Context:**
-{context}
-
-**Instructions:**
-1. Answer the user's question directly based on the provided context
-2. If the context doesn't fully answer the question, acknowledge the limitations
-3. Provide specific legal references when available in the context
-4. Include practical implications for organizations
-5. Add a disclaimer that this is for guidance purposes only
-
-Please provide a clear, well-structured response."""
-            
+            answer_prompt = RESPONSE_FORMATTING_PROMPT.format(context=context, query=state["user_query"])
             messages.append(HumanMessage(content=answer_prompt))
             
             response = await self.llm.ainvoke(messages)
             answer = response.content
-            
-            # Add references if available
-            references = state.get("relevant_documents", [])
-            if references:
-                answer += "\n\n**📚 References:**\n"
-                for ref in references[:3]:  # Limit to top 3 references
-                    answer += f"• {ref}\n"
-            
-            # Add standard disclaimer
-            answer += "\n\n**Disclaimer:** This information is for guidance purposes only and not legal advice. For specific legal matters, consult with qualified legal counsel."
-            
             state["final_response"] = answer
-            state["confidence_score"] = 0.8  # High confidence when LightRAG provides good context
             
         except Exception as e:
             state["lightrag_error"] = f"Answer generation failed: {str(e)}"
         
-        self.performance_monitor.end_timer("answer_generation")
+        answer_generation_duration = self.performance_monitor.end_timer("answer_generation")
+        logger.info(f"⏱️  Answer generation processing time: {answer_generation_duration:.3f}s")
         
         # Record total processing time
         total_time = sum(
@@ -195,31 +141,8 @@ Please provide a clear, well-structured response."""
         state["processing_time"] = total_time
         state["query_timestamp"] = datetime.now().isoformat()
         
-        return state
-    
-    async def _handle_error(self, state: AgentState) -> AgentState:
-        """
-        Handle errors gracefully
-        """
-        error = state.get("lightrag_error", "Unknown error occurred")
-        
-        error_prompt = ERROR_HANDLING_PROMPT.format(error_message=error)
-        
-        try:
-            messages = [
-                SystemMessage(content=SYSTEM_PROMPT),
-                HumanMessage(content=error_prompt)
-            ]
-            
-            response = await self.llm.ainvoke(messages)
-            state["final_response"] = response.content
-            
-        except Exception:
-            state["final_response"] = f"I apologize, but an error occurred: {error}"
-        
-        state["confidence_score"] = 0.2  # Low confidence for errors
-        state["processing_time"] = self.performance_monitor.get_metrics()
-        state["query_timestamp"] = datetime.now().isoformat()
+        logger.info(f"⏱️  Total query processing time: {total_time:.3f}s")
+        logger.info(f"📚 References found: {len(state.get('relevant_documents', []))}")
         
         return state
     
@@ -235,42 +158,40 @@ Please provide a clear, well-structured response."""
         initial_state: AgentState = {
             "user_query": user_query,
             "conversation_history": conversation_history or [],
-            "lightrag_response": None,
-            "lightrag_error": None,
             "processed_context": None,
             "relevant_documents": [],
             "analysis_thoughts": None,
-            "needs_clarification": False,
-            "clarification_question": None,
-            "final_response": None,
-            "confidence_score": None,
             "query_timestamp": datetime.now().isoformat(),
             "processing_time": None,
-            "query_type": None
         }
         
         # Reset performance monitor
         self.performance_monitor.reset()
         
         try:
+            logger.info(f"🚀 Starting query processing: {user_query[:100]}...")
+            logger.info(f"💬 Conversation history length: {len(initial_state['conversation_history'])} messages")
+            
             # Run the workflow
             final_state = await self.workflow.ainvoke(initial_state)
             
-            return {
+            result = {
                 "response": final_state.get("final_response", ""),
-                "confidence": final_state.get("confidence_score", 0.0),
                 "processing_time": final_state.get("processing_time", 0.0),
                 "references": final_state.get("relevant_documents", []),
-                "error": final_state.get("lightrag_error"),
                 "timestamp": final_state.get("query_timestamp")
             }
             
+            logger.info(f"✅ Query processing completed successfully")
+            logger.info(f"📄 Response length: {len(result['response'])} characters")
+            
+            return result
+            
         except Exception as e:
+            logger.error(f"💥 Critical error during query processing: {str(e)}")
             return {
                 "response": f"I apologize, but a critical error occurred: {str(e)}",
-                "confidence": 0.0,
                 "processing_time": 0.0,
                 "references": [],
-                "error": str(e),
                 "timestamp": datetime.now().isoformat()
             }

prompts.py

@@ -3,55 +3,14 @@
 System prompts for the LangGraph cyber-legal assistant
 """
 
-SYSTEM_PROMPT = """You are an expert cyber-legal assistant specializing in European Union regulations and directives. 
-Your expertise covers:
+SYSTEM_PROMPT = """### Role 
+You are an expert cyber-legal assistant specializing in European Union regulations and directives. 
+You must answer user's questions based on a legal knowledge, we queried a knowledge graph to about the user's question.
 
-- GDPR (General Data Protection Regulation)
-- NIS2 Directive (Network and Information Systems Directive 2)
-- DORA (Digital Operational Resilience Act)
-- Cyber Resilience Act (CRA)
-- eIDAS 2.0 (Electronic Identification, Authentication and Trust Services)
-- Romanian Civil Code provisions relevant to cyber security
-
-**Your Role:**
-Provide accurate, clear, and practical information about cyber-legal regulations. Always base your responses on the retrieved legal documents and context provided.
-
-**Guidelines:**
-1. Be precise and accurate with legal information
-2. Provide practical examples when helpful
-3. Clarify jurisdiction (EU-wide vs member state implementation)
-4. Mention important dates, deadlines, or transitional periods
-5. Include relevant penalties or enforcement mechanisms when applicable
-6. Suggest official sources for further reading
-
-**Response Structure:**
-1. Direct answer to the user's question
-2. Relevant legal basis (specific articles, sections)
-3. Practical implications
-4. Related compliance requirements
-5. References to source documents
-
-**Important Disclaimer:**
-Always include a note that this information is for guidance purposes and not legal advice. For specific legal matters, consult with qualified legal counsel."""
-
-CONTEXT_ENHANCEMENT_PROMPT = """Based on the following RAG response about European cyber-legal regulations, enhance the information by:
-
-1. **Structuring**: Organize the information in a clear, logical manner
-2. **Context**: Add relevant background information about the regulation
-3. **Practicality**: Include practical implications for organizations
-4. **Completeness**: Fill in gaps with general knowledge about EU regulations
-5. **Clarity**: Ensure complex legal concepts are explained clearly
-
-**RAG Response:**
-{lightrag_response}
-
-**Conversation Context:**
-{conversation_context}
-
-**User Query:**
-{user_query}
-
-Please provide an enhanced response that is more comprehensive and user-friendly while maintaining accuracy."""
+### Guidelines
+1. Your responses should be clear, concise, and provide a direct answer to the user's question.
+2. If you use specific knowledge from a regulation or directive, you should reference it in your response.
+4. Create a section at the end of your response called "References" that list  the source documents used to answer the user's question."""
 
 ERROR_HANDLING_PROMPT = """I apologize, but I encountered an issue while retrieving information from the legal database. 
 
@@ -73,14 +32,6 @@ ERROR_HANDLING_PROMPT = """I apologize, but I encountered an issue while retriev
 
 Would you like to try asking your question in a different way?"""
 
-CLARIFICATION_PROMPT = """To provide you with the most accurate information, I need a bit more detail about your question.
-
-**Your Question:** {user_query}
-
-**Clarification Needed:** {clarification_question}
-
-This will help me search the specific legal provisions that are most relevant to your situation."""
-
 RESPONSE_FORMATTING_PROMPT = """Format the final response according to these guidelines:
 
 1. **Clear Heading**: Start with a clear, direct answer
@@ -94,40 +45,3 @@ RESPONSE_FORMATTING_PROMPT = """Format the final response according to these gui
 {content}
 
 **User Query:** {user_query}"""
-
-FOLLOW_UP_SUGGESTIONS_PROMPT = """Based on the user's query about "{user_query}", suggest relevant follow-up questions that might be helpful:
-
-Consider:
-1. Related regulations they might need to know about
-2. Implementation or compliance aspects
-3. Similar scenarios or use cases
-4. Recent updates or changes
-
-Provide 3-4 relevant follow-up suggestions."""
-
-CONVERSATION_SUMMARY_PROMPT = """Summarize the key points discussed in this conversation about European cyber-legal regulations:
-
-**Conversation History:**
-{conversation_history}
-
-**Focus Areas:**
-- Main regulations discussed
-- Key compliance points mentioned
-- Important deadlines or requirements
-- Any specific scenarios covered
-
-Provide a concise summary that captures the essence of the legal discussion."""
-
-CONFIDENCE_ASSESSMENT_PROMPT = """Assess the confidence level of the provided response based on:
-
-1. **Source Quality**: How reliable are the referenced documents?
-2. **Information Completeness**: Does the response fully address the query?
-3. **Legal Specificity**: How specific and accurate are the legal references?
-4. **Context Relevance**: How well does it match the user's needs?
-
-**Response to Assess:**
-{response}
-
-**User Query:** {user_query}
-
-Provide a confidence score (0.0-1.0) and brief reasoning."""

test_openai_key.ipynb

@@ -37,15 +37,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "✅ OpenAI API Test Successful!\n",
-      "Response: API key works!\n"
+      "❌ OpenAI API Test Failed: Error code: 429 - {'error': {'message': 'You exceeded your current quota, please check your plan and billing details. For more information on this error, read the docs: https://platform.openai.com/docs/guides/error-codes/api-errors.', 'type': 'insufficient_quota', 'param': None, 'code': 'insufficient_quota'}}\n"
      ]
     }
    ],

utils.py

@@ -77,7 +77,9 @@ class LightRAGClient:
                 )
                 
                 if response.status_code == 200:
+                    logger.info(f"Query successful;{response.json()}")
                     return response.json()
+
                 else:
                     logger.warning(f"Query failed with status {response.status_code}, attempt {attempt + 1}")