Introduced Undo Functionality & AI Agent (for connected environment)

Author: DarshanScripts

.env

@@ -5,3 +5,4 @@ EMBEDDING_MODEL="text-embedding-3-small"
 EMBEDDING_API_VERSION="2023-05-15"
 ENDPOINT="https://ai4se-openai.openai.azure.com/"
 AZURE_OPENAI_API_KEY="VDfaCeEbTyAyPRC3C02mZyyANPxZGBxODmWOpWechSlv7GQ8zmmuJQQJ99AKACI8hq2XJ3w3AAABACOGPYeE"
+MONGODB_URI="mongodb://localhost:27017/"

README.md

@@ -10,7 +10,6 @@
 -  Classifies input as "General" or "Scenario" intelligently.
 -  Generates detailed scenarios and concise summaries using GPT models.
 -  Converts extracted domain structures into **PlantUML** diagrams.
--  Stores and manages data using **MongoDB**.
 -  Includes a full test suite for backend routes with **pytest**.
 
 ---
@@ -19,11 +18,10 @@
 
 - **Python 3.9+**
 - **Flask** (Web Framework)
-- **OpenAI API** (Azure-compatible)
-- **MongoDB** (Database)
-- **PlantUML** (Diagram rendering)
-- **dotenv** (Environment configuration)
+- **OpenAI API** (Azure variant support)
+- **PlantUML** (Diagram generation)
 - **pytest** (Testing)
+- **dotenv** (Environment management)
 
 ---
 
@@ -56,21 +54,10 @@ EMBEDDING_MODEL="text-embedding-3-small"
 EMBEDDING_API_VERSION="2023-05-15"
 ENDPOINT="https://your-azure-endpoint/"
 AZURE_OPENAI_API_KEY="your-api-key"
-MONGO_URI="mongodb://localhost:27017/domain_modelling"
 ```
 
 ### 5. Run the application
 ```bash
 python app.py
 ```
 Visit: http://localhost:5000
-
-### MongoDB Setup
-1. Install MongoDB: MongoDB Installation Guide
-
-2. Start MongoDB Server:
-
-```bash
-mongod
-```
-03. Database Connection: The app connects to MongoDB using the URI in .env (MONGO_URI). The database and collections will be created automatically.

src/controller/chat_controller.py

@@ -1,17 +1,33 @@
-from flask import request, jsonify, session
-from src.model.llm_service import LLMService
-from src.model.gpt2 import gpt_v2_interface 
-from src.model.project_service import ProjectService
+from flask import request, jsonify
+from src.model.AgentChat import AgentChat
+from src.model.AgentDomainModelDescription import AgentDomainModelDescription
+from src.model.AgentDomainModelVisualization import AgentDomainModelVisualization
+import traceback
 
 class ChatController:
-    """Controller for chat-related operations and version saving"""
+    """Controller for chat-related operations using agent-based architecture"""
 
     def __init__(self):
-        self.llm_service = LLMService()
-        self.project_service = ProjectService()
+        # Create agents
+        print("Initializing ChatController with three specialized agents")
+        self.chat_agent = AgentChat()
+        self.domain_model_agent = AgentDomainModelDescription()
+        self.visualization_agent = AgentDomainModelVisualization()
 
+        # Connect agents in a bidirectional network
+        self.chat_agent.connect("DomainModelAgent", self.domain_model_agent)
+        self.chat_agent.connect("VisualizationAgent", self.visualization_agent)
+        
+        self.domain_model_agent.connect("ChatAgent", self.chat_agent)
+        self.domain_model_agent.connect("VisualizationAgent", self.visualization_agent)
+        
+        self.visualization_agent.connect("ChatAgent", self.chat_agent)
+        self.visualization_agent.connect("DomainModelAgent", self.domain_model_agent)
+        
+        print("Agent network initialized with bidirectional connections")
+    
     def handle_chat_request(self):
-        """Process user input and generate response with version saving"""
+        """Process user input using the ChatAgent"""
         try:
             data = request.json
             user_input = data.get("message", "").strip()
@@ -20,131 +36,40 @@ def handle_chat_request(self):
             if not user_input:
                 return jsonify({"error": "User input is required"}), 400
             if not project_name:
-                return jsonify({"error": "Project name is required to save version"}), 400
-            
-            # Get the current state before processing new input
-            # This ensures we always have the latest domain model and PlantUML
-            project_result, _ = self.project_service.get_project_data(project_name)
-            current_project_data = project_result.get("project_data", {})
+                return jsonify({"error": "Project name is required"}), 400
 
-            # Get existing domain model description and PlantUML from project data
-            # These will be used as fallbacks if nothing new is generated
-            existing_dmd = current_project_data.get("domain_model_description", "Welcome to your new project! Start by describing your domain.")
-            existing_plant_uml = current_project_data.get("plant_uml", "@startuml\nskinparam monochrome true\ntitle Your New Project\n\nclass ExampleEntity {\n  +id: string\n  +name: string\n}\n\nnote \"Start building your domain model!\" as N1\n@enduml")
+            # Delegate handling to the ChatAgent
+            result = self.chat_agent.handle_user_input(user_input, project_name)
 
-            self.llm_service.add_to_chat_history("user", user_input)
-            updated_chat_history = self.llm_service.chat_history.get_messages()
-            chat_history_text = "\n".join([
-                f"{'User' if msg['role'] == 'user' else 'Assistant'}: {msg['content']}"
-                for msg in updated_chat_history
-            ])
-            
-            classification_result = self.llm_service.determine_input_type(chat_history_text)
-            
-            decision = classification_result.get("decision", False)
-            is_casual_comment = classification_result.get("is_casual_comment", False)
-            suggestions = classification_result.get("suggestions", [])
-            assistant_response = "\n".join(suggestions) if isinstance(suggestions, list) else suggestions
-
-            # Set initial state using existing values to ensure we never store nulls
-            current_dmd = self.llm_service.get_current_domain_model_description() or existing_dmd
-            current_plant_uml = existing_plant_uml
-
-            if is_casual_comment:
-                self.llm_service.add_to_chat_history("assistant", assistant_response)
-                
-                # Use existing domain model and PlantUML (already set above)
-                # If DMD exists but PlantUML doesn't, generate PlantUML
-                if current_dmd and not current_plant_uml:
-                    client = self.llm_service.client
-                    current_plant_uml = gpt_v2_interface(current_dmd, client)
+            if "error" in result:
+                return jsonify({"error": result["error"]}), 400
 
-                self.project_service.save_version(
-                    project_name,
-                    user_input,
-                    assistant_response,
-                    current_dmd,
-                    current_plant_uml
-                )
-                return jsonify({
-                    "response": assistant_response,
-                    "history": self.llm_service.get_chat_history(),
-                    "domain_model_description": current_dmd,
-                    "plant_uml": current_plant_uml
-                })
-                
-            elif decision: # Enough information for domain modeling (new or update)
-                new_dmd = self.llm_service.generate_domain_model_description(chat_history_text)
-                self.llm_service.add_to_chat_history("assistant", assistant_response)
-                
-                # Generate PlantUML for the new/updated DMD
-                client = self.llm_service.client
-                new_plant_uml = ""
-                if new_dmd:
-                    new_plant_uml = gpt_v2_interface(new_dmd, client)
-                else:
-                    new_dmd = current_dmd  # Fallback to existing DMD
-                    new_plant_uml = current_plant_uml  # Fallback to existing PlantUML
-
-                self.project_service.save_version(
-                    project_name,
-                    user_input,
-                    assistant_response,
-                    new_dmd,
-                    new_plant_uml
-                )
-                
-                return jsonify({
-                    "domain_model_description": new_dmd, 
-                    "suggestion": assistant_response,
-                    "plant_uml": new_plant_uml
-                })
-                
-            else: # Not enough info for domain modeling
-                self.llm_service.add_to_chat_history("assistant", assistant_response)
-                
-                # Use existing domain model and PlantUML
-                # If we have a domain model but no PlantUML, generate it
-                if current_dmd and not current_plant_uml:
-                    client = self.llm_service.client
-                    current_plant_uml = gpt_v2_interface(current_dmd, client)
-
-                self.project_service.save_version(
-                    project_name,
-                    user_input,
-                    assistant_response,
-                    current_dmd,
-                    current_plant_uml
-                )
-                
-                return jsonify({
-                    "response": assistant_response, 
-                    "history": self.llm_service.get_chat_history(),
-                    "domain_model_description": current_dmd,
-                    "plant_uml": current_plant_uml
-                })
+            return jsonify(result)
 
         except Exception as e:
             print(f"Error in chat request: {e}")
-            import traceback
             traceback.print_exc()
             return jsonify({"error": "An unexpected error occurred"}), 500
 
     def generate_uml(self):
-        """Generate UML diagram from domain model description"""
+        """Generate UML diagram from domain model description using VisualizationAgent"""
         try:
             domain_model_description_text = request.json.get("domainModelDescriptionText", "").strip()
             if not domain_model_description_text:
                 return jsonify({"error": "Domain Model Description is required"}), 400
 
-            client = self.llm_service.client
-            plant_uml = gpt_v2_interface(domain_model_description_text, client)
-            return jsonify({"plantuml": plant_uml})
+            # Use visualization agent to generate PlantUML
+            result = self.visualization_agent.generate_plantuml(domain_model_description_text)
+            
+            if "error" in result:
+                return jsonify({"error": result["error"]}), 400
+                
+            return jsonify({"plantuml": result["plant_uml"]})
         except Exception as e:
             print(f"Error generating UML: {e}")
             return jsonify({"error": "An error occurred while generating the UML"}), 500
 
     def get_current_domain_model_description(self):
-        """Retrieve the current domain model description"""
-        domain_model_description = self.llm_service.get_current_domain_model_description()
-        return jsonify({"domain_model_description": domain_model_description})
+        """Retrieve the current domain model description from DomainModelAgent"""
+        result = self.domain_model_agent.get_domain_model()
+        return jsonify({"domain_model_description": result.get("domain_model_description")})