${task.description}
16 |Status: ${task.status}
17 |Priority: ${task.priority}
18 |${project.description}
17 | 18 |${project.description}
14 | 15 | 16 | 17 | `; 18 | }) 19 | .catch(error => console.error('Error loading project details:', error)); 20 | } 21 | 22 | function showCreateTaskForm(projectId) { 23 | app.innerHTML += ` 24 |${response}
`; 57 | }) 58 | .catch(error => console.error('Error asking AI:', error)); 59 | } 60 | 61 | // Make functions global so they can be called from inline onclick handlers 62 | window.loadTasks = loadTasks; 63 | window.showCreateTaskForm = showCreateTaskForm; 64 | window.showAIAssistant = showAIAssistant; 65 | window.handleAskAI = handleAskAI; -------------------------------------------------------------------------------- /backend/ai_engine/workflow/state_manager.py: -------------------------------------------------------------------------------- 1 | from typing import Dict, Any, List 2 | from pydantic import BaseModel, Field 3 | 4 | 5 | class Task(BaseModel): 6 | title: str 7 | description: str 8 | status: str 9 | priority: str = None 10 | estimated_duration: float 11 | actual_duration: float = None 12 | required_skills: List[str] 13 | suggestions: Dict[str, Any] = None 14 | collaboration: Dict[str, Any] = None 15 | 16 | class WorkflowState(BaseModel): 17 | project_id: int 18 | input_description: str 19 | tasks: List[Task] = Field(default_factory=list) 20 | generate_report: bool = False 21 | report: Dict[str, Any] = None 22 | 23 | class StateManager: 24 | @staticmethod 25 | def initialize_state(project_id: int, input_description: str) -> WorkflowState: 26 | return WorkflowState( 27 | project_id=project_id, 28 | input_description=input_description 29 | ) 30 | 31 | @staticmethod 32 | def update_state(state: WorkflowState, updates: Dict[str, Any]) -> WorkflowState: 33 | for key, value in updates.items(): 34 | if hasattr(state, key): 35 | setattr(state, key, value) 36 | return state 37 | 38 | @staticmethod 39 | def add_task(state: WorkflowState, task: Dict[str, Any]) -> WorkflowState: 40 | state.tasks.append(Task(**task)) 41 | return state 42 | 43 | @staticmethod 44 | def update_task(state: WorkflowState, task_index: int, updates: Dict[str, Any]) -> WorkflowState: 45 | if 0 <= task_index < len(state.tasks): 46 | task = state.tasks[task_index] 47 | for key, value in updates.items(): 48 | if hasattr(task, key): 49 | setattr(task, key, value) 50 | return state 51 | 52 | @staticmethod 53 | def set_generate_report(state: WorkflowState, generate: bool) -> WorkflowState: 54 | state.generate_report = generate 55 | return state 56 | 57 | @staticmethod 58 | def get_state_summary(state: WorkflowState) -> Dict[str, Any]: 59 | return { 60 | "project_id": state.project_id, 61 | "total_tasks": len(state.tasks), 62 | "tasks_by_status": {status: sum(1 for task in state.tasks if task.status == status) for status in set(task.status for task in state.tasks)}, 63 | "generate_report": state.generate_report 64 | } 65 | 66 | @staticmethod 67 | def get_task_by_title(state: WorkflowState, title: str) -> Task: 68 | for task in state.tasks: 69 | if task.title == title: 70 | return task 71 | return None 72 | 73 | @staticmethod 74 | def get_all_tasks(state: WorkflowState) -> List[Task]: 75 | return state.tasks 76 | 77 | @staticmethod 78 | def clear_tasks(state: WorkflowState) -> WorkflowState: 79 | state.tasks = [] 80 | return state -------------------------------------------------------------------------------- /backend/ai_engine/agents/collaboration_agent.py: -------------------------------------------------------------------------------- 1 | # from langchain_community.chat_models import ChatOpenAI 2 | from langchain_groq import ChatGroq 3 | from langchain.prompts import ChatPromptTemplate 4 | from langchain.output_parsers import PydanticOutputParser 5 | from pydantic import BaseModel, Field 6 | from typing import List, Dict , Any 7 | from backend.ai_engine.rag.retriever import Retriever 8 | from dotenv import load_dotenv 9 | import os 10 | 11 | load_dotenv() 12 | 13 | class TeamFormation(BaseModel): 14 | member_name: str = Field(description="Name of the team member") 15 | role: str = Field(description="Assigned role for the task") 16 | 17 | class CollaborationOutput(BaseModel): 18 | team_formation: List[TeamFormation] = Field(description="Suggested team formation for the task") 19 | communication_plan: str = Field(description="Suggested communication plan for the team") 20 | 21 | class CollaborationAgent: 22 | """CollaborationAgent class to suggest team formation and communication plan for a task""" 23 | def __init__(self, retriever: Retriever,model_name: str = "gpt-3.5-turbo"): 24 | self.llm = ChatGroq(groq_api_key=os.getenv("GROQ_API_KEY"), 25 | model="mixtral-8x7b-32768", 26 | temperature=0, 27 | max_tokens=None, 28 | timeout=None, 29 | max_retries=2,) 30 | self.parser = PydanticOutputParser(pydantic_object=CollaborationOutput) 31 | self.retriever = retriever 32 | 33 | self.collaboration_prompt = ChatPromptTemplate.from_template( 34 | "Suggest a team formation and communication plan for the following task:\n" 35 | "Task: {task_description}\n" 36 | "Available team members: {available_team_members}\n" 37 | "Project context: {project_context}\n" 38 | "Similar past collaborations: {similar_collaborations}\n" 39 | "{format_instructions}" 40 | ) 41 | 42 | def suggest_collaboration(self, task: Dict[str, Any], project_id: int) -> Dict[str, Any]: 43 | """Suggest team formation and communication plan for a task""" 44 | available_team_members = self.retriever.get_available_team_members(project_id) 45 | project_context = self.retriever.get_project_context(project_id) 46 | similar_collaborations = self.retriever.get_similar_collaborations(task['description'], project_id) 47 | 48 | prompt = self.collaboration_prompt.format( 49 | task_description=f"{task['title']} (Duration: {task['estimated_duration']}, Skills: {', '.join(task['required_skills'])})", 50 | available_team_members=available_team_members, 51 | project_context=project_context, 52 | similar_collaborations=similar_collaborations, 53 | format_instructions=self.parser.get_format_instructions() 54 | ) 55 | response = self.llm(prompt) 56 | collaboration_info = self.parser.parse(response.content) 57 | 58 | return collaboration_info.dict() -------------------------------------------------------------------------------- /backend/database/models.py: -------------------------------------------------------------------------------- 1 | from sqlalchemy import Column, Integer, String, DateTime, ForeignKey, Table, Date, Boolean, Float 2 | from sqlalchemy.orm import relationship 3 | from sqlalchemy.ext.declarative import declarative_base 4 | from datetime import datetime 5 | 6 | Base = declarative_base() 7 | project_team_members = Table('project_team_members', Base.metadata, 8 | Column('project_id', Integer, ForeignKey('projects.id')), 9 | Column('team_member_id', Integer, ForeignKey('team_members.id')) 10 | ) 11 | 12 | 13 | class User(Base): 14 | __tablename__ = "users" 15 | 16 | id = Column(Integer, primary_key=True, index=True) 17 | username = Column(String, unique=True, index=True) 18 | email = Column(String, unique=True, index=True) 19 | hashed_password = Column(String) 20 | is_active = Column(Boolean, default=True) 21 | 22 | projects = relationship("Project", back_populates="owner") 23 | 24 | class Project(Base): 25 | __tablename__ = 'projects' 26 | 27 | id = Column(Integer, primary_key=True) 28 | name = Column(String, nullable=False) 29 | description = Column(String) 30 | start_date = Column(Date) 31 | end_date = Column(Date) 32 | status = Column(String) 33 | created_at = Column(DateTime, nullable=False, default=datetime.utcnow) 34 | updated_at = Column(DateTime) 35 | 36 | owner_id = Column(Integer, ForeignKey("users.id")) 37 | owner = relationship("User", back_populates="projects") 38 | tasks = relationship("Task", back_populates="project") 39 | team_members = relationship("TeamMember", secondary=project_team_members, back_populates="projects") 40 | 41 | class Task(Base): 42 | __tablename__ = 'tasks' 43 | 44 | id = Column(Integer, primary_key=True) 45 | title = Column(String, nullable=False) 46 | description = Column(String) 47 | status = Column(String, nullable=False) 48 | priority = Column(String) 49 | priority_reasoning = Column(String) 50 | estimated_duration = Column(Float) 51 | actual_duration = Column(Float) 52 | created_at = Column(DateTime, nullable=False, default=datetime.utcnow) 53 | updated_at = Column(DateTime) 54 | due_date = Column(Date) 55 | required_skills = Column(String) # Store as JSON string 56 | 57 | project_id = Column(Integer, ForeignKey('projects.id')) 58 | project = relationship("Project", back_populates="tasks") 59 | assigned_to_id = Column(Integer, ForeignKey('team_members.id')) 60 | assigned_to = relationship("TeamMember", back_populates="assigned_tasks") 61 | 62 | class TeamMember(Base): 63 | __tablename__ = 'team_members' 64 | 65 | id = Column(Integer, primary_key=True) 66 | name = Column(String, nullable=False) 67 | email = Column(String, unique=True) 68 | role = Column(String) 69 | skills = Column(String) 70 | 71 | assigned_tasks = relationship("Task", back_populates="assigned_to") 72 | projects = relationship("Project", secondary=project_team_members, back_populates="team_members") -------------------------------------------------------------------------------- /backend/database/schemas.py: -------------------------------------------------------------------------------- 1 | from pydantic import BaseModel, Field, validator 2 | from typing import List, Optional 3 | from datetime import datetime, date 4 | import json 5 | 6 | 7 | class TaskBase(BaseModel): 8 | title: str 9 | description: Optional[str] = None 10 | status: Optional[str] = "New" 11 | priority: Optional[str] = None 12 | estimated_duration: Optional[float] = None 13 | due_date: Optional[date] = None 14 | required_skills: Optional[List[str]] = None 15 | 16 | class TaskCreate(TaskBase): 17 | pass 18 | 19 | class Task(TaskBase): 20 | id: int 21 | created_at: datetime 22 | updated_at: Optional[datetime] = None 23 | project_id: int 24 | assigned_to_id: Optional[int] = None 25 | priority: Optional[str] = None 26 | priority_reasoning: Optional[str] = None 27 | 28 | @validator('required_skills', pre=True) 29 | def parse_required_skills(cls, v): 30 | if isinstance(v, str): 31 | return json.loads(v) 32 | return v 33 | 34 | class Config: 35 | from_attributes = True 36 | 37 | class TeamMemberBase(BaseModel): 38 | name: str 39 | email: str 40 | role: Optional[str] = None 41 | skills: Optional[List[str]] = None 42 | 43 | class TeamMemberCreate(TeamMemberBase): 44 | pass 45 | 46 | class TeamMemberInDB(TeamMemberBase): 47 | id: int 48 | skills: Optional[str] = None # This will be the JSON string stored in the database 49 | 50 | class Config: 51 | from_attributes = True 52 | 53 | class ProjectBase(BaseModel): 54 | name: str 55 | description: Optional[str] = None 56 | start_date: Optional[date] = None 57 | end_date: Optional[date] = None 58 | status: Optional[str] = None 59 | 60 | class ProjectCreate(ProjectBase): 61 | pass 62 | 63 | class TeamMemberBase(BaseModel): 64 | id: int 65 | name: str 66 | email: str 67 | role: Optional[str] = None 68 | skills: Optional[List[str]] = None 69 | 70 | class TeamMember(TeamMemberBase): 71 | id: int 72 | assigned_tasks: List[Task] = [] 73 | 74 | class Config: 75 | from_attributes = True 76 | 77 | class ProjectOut(ProjectBase): 78 | id: int 79 | created_at: datetime 80 | updated_at: Optional[datetime] = None 81 | tasks: List[Task] = [] 82 | team_members: List[TeamMember] = [] 83 | 84 | class Config: 85 | from_attributes = True 86 | 87 | class Project(ProjectBase): 88 | id: int 89 | created_at: datetime 90 | updated_at: Optional[datetime] = None 91 | tasks: List[Task] = [] 92 | team_members: List[TeamMemberBase] = [] 93 | 94 | class Config: 95 | from_attributes = True 96 | 97 | class UserBase(BaseModel): 98 | username: str 99 | email: str 100 | 101 | class UserCreate(UserBase): 102 | password: str 103 | 104 | class User(UserBase): 105 | id: int 106 | is_active: bool 107 | projects: List[Project] = [] 108 | 109 | class Config: 110 | from_attributes = True -------------------------------------------------------------------------------- /backend/ai_engine/rag/vector_store.py: -------------------------------------------------------------------------------- 1 | import faiss 2 | from langchain_community.vectorstores import FAISS 3 | from langchain_ollama import OllamaEmbeddings 4 | from langchain.schema import Document 5 | from typing import List, Dict, Any 6 | import os 7 | from dotenv import load_dotenv 8 | 9 | load_dotenv() 10 | 11 | class VectorStore: 12 | def __init__(self): 13 | self.embeddings = OllamaEmbeddings(model="all-minilm") 14 | self.vector_store = None 15 | 16 | def create_vector_store(self, texts: List[str], metadatas: List[Dict[str, Any]]): 17 | documents = [Document(page_content=text, metadata=metadata) for text, metadata in zip(texts, metadatas)] 18 | try: 19 | print(f"Creating FAISS index with {len(documents)} documents") 20 | print(f"Embedding dimension: {len(self.embeddings.embed_query('test'))}") 21 | self.vector_store = FAISS.from_documents(documents, self.embeddings) 22 | print("FAISS index created successfully") 23 | except Exception as e: 24 | print(f"Error creating vector store: {e}") 25 | print("Falling back to in-memory storage without embeddings.") 26 | self.vector_store = InMemoryStore(documents) 27 | 28 | def add_texts(self, texts: List[str], metadatas: List[Dict[str, Any]]): 29 | if self.vector_store is None: 30 | self.create_vector_store(texts, metadatas) 31 | else: 32 | try: 33 | self.vector_store.add_texts(texts, metadatas=metadatas) 34 | except Exception as e: 35 | print(f"Error adding texts to vector store: {e}") 36 | 37 | def similarity_search(self, query: str, k: int = 4) -> List[Document]: 38 | if self.vector_store is None: 39 | self.initialize_with_dummy_data() 40 | try: 41 | return self.vector_store.similarity_search(query, k=k) 42 | except Exception as e: 43 | print(f"Error performing similarity search: {e}") 44 | return [] 45 | 46 | def initialize_with_dummy_data(self): 47 | dummy_texts = [ 48 | "This is a dummy task for initializing the vector store.", 49 | "Another dummy task to ensure the vector store is not empty.", 50 | "A third dummy task for good measure." 51 | ] 52 | dummy_metadatas = [ 53 | {"title": "Dummy Task 1", "project_id": 0}, 54 | {"title": "Dummy Task 2", "project_id": 0}, 55 | {"title": "Dummy Task 3", "project_id": 0} 56 | ] 57 | self.create_vector_store(dummy_texts, dummy_metadatas) 58 | print("Vector store initialized with dummy data.") 59 | 60 | class InMemoryStore: 61 | def __init__(self, documents: List[Document]): 62 | self.documents = documents 63 | def similarity_search(self, query: str, k: int = 4) -> List[Document]: 64 | return self.documents[:k] 65 | 66 | def add_texts(self, texts: List[str], metadatas: List[Dict[str, Any]]): 67 | new_docs = [Document(page_content=text, metadata=metadata) for text, metadata in zip(texts, metadatas)] 68 | self.documents.extend(new_docs) 69 | 70 | vector_store = VectorStore() -------------------------------------------------------------------------------- /backend/ai_engine/agents/suggestion_agent.py: -------------------------------------------------------------------------------- 1 | # from langchain_community.chat_models import ChatOpenAI 2 | from langchain_groq import ChatGroq 3 | from langchain.prompts import ChatPromptTemplate 4 | from langchain.output_parsers import PydanticOutputParser 5 | from langchain.schema import HumanMessage, SystemMessage 6 | from pydantic import BaseModel, Field 7 | from typing import List, Dict, Any 8 | from backend.ai_engine.rag.retriever import Retriever 9 | from dotenv import load_dotenv 10 | import os 11 | import re 12 | 13 | 14 | load_dotenv() 15 | 16 | class SuggestionOutput(BaseModel): 17 | suggestions: List[str] = Field(description="List of suggestions for completing the task") 18 | resources: List[str] = Field(description="List of recommended resources for the task") 19 | 20 | class SuggestionAgent: 21 | def __init__(self, retriever: Retriever,model_name: str = "gpt-3.5-turbo"): 22 | self.llm = ChatGroq(groq_api_key=os.getenv("GROQ_API_KEY"), 23 | model="mixtral-8x7b-32768", 24 | temperature=0, 25 | max_tokens=None, 26 | timeout=None, 27 | max_retries=2,) 28 | self.parser = PydanticOutputParser(pydantic_object=SuggestionOutput) 29 | self.retriever = retriever 30 | 31 | self.suggestion_prompt = ChatPromptTemplate.from_template( 32 | "Provide suggestions and resources for completing the following task:\n" 33 | "Task: {task_description}\n" 34 | "Project context: {project_context}\n" 35 | "Similar completed tasks: {similar_tasks}\n" 36 | "Team member skills: {team_skills}\n" 37 | "{format_instructions}" 38 | ) 39 | 40 | def generate_suggestions(self, task: Dict[str, Any], project_id: int) -> Dict[str, Any]: 41 | project_context = self.retriever.get_project_context(project_id) 42 | similar_tasks = self.retriever.get_similar_completed_tasks(task['description'], project_id) 43 | team_skills = self.retriever.get_team_skills(project_id) 44 | 45 | task_description = f"{task['title']} (Duration: {task['estimated_duration']}, Skills: {', '.join(task['required_skills'])})" 46 | system_message = SystemMessage(content="You are a project management AI assistant. Provide suggestions and resources for completing the given task.") 47 | human_message = HumanMessage(content=f""" 48 | Task: {task_description} 49 | Project context: {project_context} 50 | Similar completed tasks: {similar_tasks} 51 | Team member skills: {team_skills} 52 | 53 | Please provide suggestions for completing this task and recommend relevant resources. 54 | """) 55 | 56 | messages = [system_message, human_message] 57 | 58 | response = self.llm.invoke(messages) 59 | 60 | # Parse the response content manually 61 | content = response.content 62 | suggestions = re.findall(r'\d+\.\s*\*\*(.*?)\*\*:', content, re.DOTALL) 63 | resources = re.findall(r'\d+\.\s*\*\*(.*?)\*\*:', content.split("Recommended resources:")[1], re.DOTALL) if "Recommended resources:" in content else [] 64 | 65 | suggestion_info = { 66 | "suggestions": suggestions, 67 | "resources": resources 68 | } 69 | 70 | return suggestion_info -------------------------------------------------------------------------------- /backend/ai_engine/utils/helpers.py: -------------------------------------------------------------------------------- 1 | import re 2 | from typing import List, Dict, Any 3 | from datetime import datetime, timedelta 4 | from sqlalchemy.orm import class_mapper 5 | 6 | def extract_list_from_string(s: str) -> List[str]: 7 | """Extract a list of items from a comma-separated string.""" 8 | return [item.strip() for item in s.split(',') if item.strip()] 9 | 10 | def parse_duration(duration_str: str) -> timedelta: 11 | """Parse a duration string (e.g., '2 hours', '3 days') into a timedelta object.""" 12 | match = re.match(r'(\d+)\s*(hour|day|week)s?', duration_str.lower()) 13 | if not match: 14 | return timedelta() 15 | 16 | amount, unit = match.groups() 17 | amount = int(amount) 18 | 19 | if unit == 'hour': 20 | return timedelta(hours=amount) 21 | elif unit == 'day': 22 | return timedelta(days=amount) 23 | elif unit == 'week': 24 | return timedelta(weeks=amount) 25 | 26 | def calculate_project_metrics(tasks: List[Dict[str, Any]]) -> Dict[str, Any]: 27 | """Calculate various project metrics based on the tasks.""" 28 | total_tasks = len(tasks) 29 | completed_tasks = sum(1 for task in tasks if task['status'] == 'Completed') 30 | total_duration = sum((task['actual_duration'] or task['estimated_duration']) for task in tasks) 31 | 32 | return { 33 | 'total_tasks': total_tasks, 34 | 'completed_tasks': completed_tasks, 35 | 'completion_rate': completed_tasks / total_tasks if total_tasks > 0 else 0, 36 | 'total_duration': total_duration, 37 | 'average_task_duration': total_duration / total_tasks if total_tasks > 0 else 0 38 | } 39 | 40 | def format_timedelta(td: timedelta) -> str: 41 | """Format a timedelta object into a human-readable string.""" 42 | days, seconds = td.days, td.seconds 43 | hours = seconds // 3600 44 | minutes = (seconds % 3600) // 60 45 | 46 | parts = [] 47 | if days > 0: 48 | parts.append(f"{days} day{'s' if days > 1 else ''}") 49 | if hours > 0: 50 | parts.append(f"{hours} hour{'s' if hours > 1 else ''}") 51 | if minutes > 0: 52 | parts.append(f"{minutes} minute{'s' if minutes > 1 else ''}") 53 | 54 | return ', '.join(parts) if parts else "0 minutes" 55 | 56 | def sanitize_input(input_string: str) -> str: 57 | """Remove any potentially harmful characters from input strings.""" 58 | return re.sub(r'[^\w\s-]', '', input_string).strip() 59 | 60 | def generate_task_id(project_id: int, task_title: str) -> str: 61 | """Generate a unique task ID based on project ID and task title.""" 62 | sanitized_title = sanitize_input(task_title) 63 | return f"{project_id}-{sanitized_title[:20]}-{datetime.now().strftime('%Y%m%d%H%M%S')}" 64 | 65 | def calculate_task_priority_score(task: Dict[str, Any], project_context: Dict[str, Any]) -> float: 66 | """Calculate a priority score for a task based on various factors.""" 67 | score = 0 68 | if task['priority'] == 'High': 69 | score += 3 70 | elif task['priority'] == 'Medium': 71 | score += 2 72 | elif task['priority'] == 'Low': 73 | score += 1 74 | 75 | return score 76 | 77 | def model_to_dict(obj): 78 | return {c.key: getattr(obj, c.key) 79 | for c in class_mapper(obj.__class__).columns} -------------------------------------------------------------------------------- /backend/ai_engine/agents/task_agent.py: -------------------------------------------------------------------------------- 1 | import os 2 | from langchain_groq import ChatGroq 3 | from langchain.prompts import ChatPromptTemplate 4 | from langchain.output_parsers import PydanticOutputParser 5 | from pydantic import BaseModel, Field 6 | from typing import List 7 | import datetime 8 | from dotenv import load_dotenv 9 | from backend.ai_engine.rag.retriever import Retriever 10 | from langchain.schema import HumanMessage, SystemMessage 11 | 12 | load_dotenv() 13 | class TaskOutput(BaseModel): 14 | title: str = Field(description="Title of the task") 15 | estimated_duration: float = Field(description="Estimated duration of the task in hours") 16 | required_skills: List[str] = Field(description="List of skills required for the task") 17 | priority: str = Field(description="Priority of the task (High, Medium, Low)") 18 | 19 | class TaskAgent: 20 | def __init__(self, retriever: Retriever): 21 | self.llm = ChatGroq(groq_api_key=os.getenv("GROQ_API_KEY"), 22 | model="mixtral-8x7b-32768", 23 | temperature=0, 24 | max_tokens=None, 25 | timeout=None, 26 | max_retries=2,) 27 | self.parser = PydanticOutputParser(pydantic_object=TaskOutput) 28 | self.retriever = retriever 29 | 30 | self.task_creation_prompt = ChatPromptTemplate.from_template( 31 | "Create a task based on the following description: {description}. " 32 | "Consider these similar tasks: {similar_tasks}. " 33 | "Project context: {project_context}. " 34 | "{format_instructions}" 35 | ) 36 | 37 | def create_task(self, description: str, project_id: int) -> dict: 38 | try: 39 | similar_tasks = self.retriever.get_similar_tasks(description, project_id) 40 | project_context = self.retriever.get_project_context(project_id) 41 | team_skills = self.retriever.get_team_skills(project_id) 42 | except Exception as e: 43 | print(f"Error retrieving data: {e}") 44 | similar_tasks = [] 45 | project_context = {} 46 | team_skills = {} 47 | 48 | messages = [ 49 | SystemMessage(content="You are a task creation assistant for a project management system."), 50 | HumanMessage(content=f"Create a task based on the following description: {description}. " 51 | f"Consider these similar tasks: {similar_tasks}. " 52 | f"Project context: {project_context}. " 53 | f"Available team skills: {team_skills}. " 54 | f"Provide a title, estimated duration, and required skills.") 55 | ] 56 | 57 | try: 58 | response = self.llm(messages) 59 | print(f"LLM Response: {response}") # Debug print 60 | task_info = self.parser.parse(response.content) 61 | return { 62 | 'title': task_info.title, 63 | 'description': description, 64 | 'estimated_duration': task_info.estimated_duration, 65 | 'required_skills': task_info.required_skills, 66 | 'created_at': datetime.datetime.now().isoformat(), 67 | 'status': 'New', 68 | 'project_id': project_id 69 | } 70 | except Exception as e: 71 | print(f"Error in create_task: {e}") 72 | return { 73 | 'title': f"Task: {description[:50]}", 74 | 'description': description, 75 | 'estimated_duration': None, 76 | 'required_skills': [], 77 | 'created_at': datetime.datetime.now().isoformat(), 78 | 'status': 'New', 79 | 'project_id': project_id 80 | } -------------------------------------------------------------------------------- /backend/tests/test_rag.py: -------------------------------------------------------------------------------- 1 | import pytest 2 | from unittest.mock import Mock, patch 3 | from backend.ai_engine.rag.vector_store import VectorStore 4 | from backend.ai_engine.rag.retriever import Retriever 5 | 6 | @pytest.fixture 7 | def mock_db(): 8 | return Mock() 9 | 10 | @pytest.fixture 11 | def mock_vector_store(): 12 | with patch('backend.ai_engine.rag.vector_store.FAISS') as mock_faiss: 13 | mock_vs = VectorStore() 14 | mock_vs.vector_store = Mock() 15 | yield mock_vs 16 | 17 | def test_vector_store_creation(mock_vector_store): 18 | texts = ["Test document 1", "Test document 2"] 19 | metadatas = [{"source": "test1"}, {"source": "test2"}] 20 | 21 | mock_vector_store.create_vector_store(texts, metadatas) 22 | 23 | mock_vector_store.vector_store.from_documents.assert_called_once() 24 | 25 | def test_vector_store_similarity_search(mock_vector_store): 26 | mock_vector_store.vector_store.similarity_search.return_value = [ 27 | Mock(page_content="Similar document 1", metadata={"source": "test1"}), 28 | Mock(page_content="Similar document 2", metadata={"source": "test2"}) 29 | ] 30 | 31 | results = mock_vector_store.similarity_search("test query", k=2) 32 | 33 | assert len(results) == 2 34 | assert results[0].page_content == "Similar document 1" 35 | assert results[1].metadata["source"] == "test2" 36 | 37 | def test_retriever_get_similar_tasks(mock_db): 38 | with patch('backend.ai_engine.rag.retriever.vector_store') as mock_vs: 39 | mock_vs.similarity_search.return_value = [ 40 | Mock(metadata={"title": "Similar Task 1"}, page_content="Description 1"), 41 | Mock(metadata={"title": "Similar Task 2"}, page_content="Description 2") 42 | ] 43 | 44 | retriever = Retriever(mock_db) 45 | similar_tasks = retriever.get_similar_tasks("New task description", project_id=1, k=2) 46 | 47 | assert len(similar_tasks) == 2 48 | assert similar_tasks[0]["title"] == "Similar Task 1" 49 | assert similar_tasks[1]["description"] == "Description 2" 50 | 51 | def test_retriever_get_project_context(mock_db): 52 | mock_db.query().filter().first.return_value = Mock( 53 | name="Test Project", 54 | description="A test project", 55 | start_date="2023-01-01", 56 | end_date="2023-12-31", 57 | status="In Progress" 58 | ) 59 | 60 | retriever = Retriever(mock_db) 61 | context = retriever.get_project_context(project_id=1) 62 | 63 | assert context["name"] == "Test Project" 64 | assert context["status"] == "In Progress" 65 | 66 | def test_retriever_get_team_skills(mock_db): 67 | mock_db.query().filter().all.return_value = [ 68 | Mock(name="Alice", skills=["Python", "JavaScript"]), 69 | Mock(name="Bob", skills=["Java", "C++"]) 70 | ] 71 | 72 | retriever = Retriever(mock_db) 73 | skills = retriever.get_team_skills(project_id=1) 74 | 75 | assert skills == { 76 | "Alice": ["Python", "JavaScript"], 77 | "Bob": ["Java", "C++"] 78 | } 79 | 80 | def test_retriever_get_similar_projects(mock_db): 81 | with patch('backend.ai_engine.rag.retriever.vector_store') as mock_vs: 82 | mock_vs.similarity_search.return_value = [ 83 | Mock(metadata={"name": "Similar Project 1"}, page_content="Description 1"), 84 | Mock(metadata={"name": "Similar Project 2"}, page_content="Description 2") 85 | ] 86 | 87 | retriever = Retriever(mock_db) 88 | similar_projects = retriever.get_similar_projects(project_id=1, k=2) 89 | 90 | assert len(similar_projects) == 2 91 | assert similar_projects[0]["name"] == "Similar Project 1" 92 | assert similar_projects[1]["description"] == "Description 2" 93 | -------------------------------------------------------------------------------- /backend/ai_engine/agents/priority_agent.py: -------------------------------------------------------------------------------- 1 | # from langchain_community.chat_models import ChatOpenAI 2 | from langchain_groq import ChatGroq 3 | from langchain.prompts import ChatPromptTemplate 4 | from langchain.output_parsers import PydanticOutputParser 5 | from pydantic import BaseModel, Field 6 | from backend.ai_engine.rag.retriever import Retriever 7 | from dotenv import load_dotenv 8 | from langchain.schema import HumanMessage, SystemMessage 9 | import os 10 | 11 | load_dotenv() 12 | 13 | 14 | class PriorityOutput(BaseModel): 15 | priority: str = Field(description="Priority level of the task (High, Medium, Low)") 16 | reasoning: str = Field(description="Reasoning behind the priority assignment") 17 | 18 | class PriorityAgent: 19 | """PriorityAgent class to assign a priority to a task""" 20 | def __init__(self, retriever: Retriever, model_name: str = "gpt-3.5-turbo"): 21 | self.llm = ChatGroq(groq_api_key=os.getenv("GROQ_API_KEY"), 22 | model="mixtral-8x7b-32768", 23 | temperature=0, 24 | max_tokens=None, 25 | timeout=None, 26 | max_retries=2,) 27 | self.parser = PydanticOutputParser(pydantic_object=PriorityOutput) 28 | self.retriever = retriever 29 | 30 | self.priority_prompt = ChatPromptTemplate.from_template( 31 | "Assign a priority to the following task: {task_description}\n" 32 | "Consider the task's complexity, estimated duration, and required skills.\n" 33 | "Project context: {project_context}\n" 34 | "Similar tasks priorities: {similar_tasks_priorities}\n" 35 | "{format_instructions}" 36 | ) 37 | 38 | def assign_priority(self, task: dict) -> dict: 39 | """Assign a priority to a task 40 | for example: 41 | task = { 42 | "title": "Design a new logo", 43 | "description": "Design a new logo for the company website", 44 | "estimated_duration": "2 days", 45 | "required_skills": ["Graphic Design", "Adobe Illustrator"], 46 | "project_id": 1 47 | } 48 | if the task is to design a new logo, the agent should assign a priority level (High, Medium, Low) and provide reasoning. 49 | if error occurs, return default priority and reasoning. 50 | """ 51 | project_context = self.retriever.get_project_context(task['project_id']) 52 | similar_tasks_priorities = self.retriever.get_similar_tasks_priorities(task['description'], task['project_id']) 53 | team_skills = self.retriever.get_team_skills(task['project_id']) 54 | 55 | task_description = f"{task['title']}" 56 | if task.get('estimated_duration'): 57 | task_description += f" (Duration: {task['estimated_duration']})" 58 | if task.get('required_skills'): 59 | task_description += f" (Skills: {', '.join(task['required_skills'])})" 60 | 61 | messages = [ 62 | SystemMessage(content="You are a task prioritization assistant for a project management system."), 63 | HumanMessage(content=f"Assign a priority to the following task: {task_description}\n" 64 | f"Consider the task's complexity, estimated duration, and required skills.\n" 65 | f"Project context: {project_context}\n" 66 | f"Similar tasks priorities: {similar_tasks_priorities}\n" 67 | f"Team skills: {team_skills}\n" 68 | f"Provide the priority (High, Medium, or Low) and reasoning.") 69 | ] 70 | 71 | try: 72 | response = self.llm(messages) 73 | priority_info = self.parser.parse(response.content) 74 | return priority_info.dict() 75 | except Exception as e: 76 | print(f"Error in assign_priority: {e}") 77 | return {"priority": "Medium", "reasoning": "Default priority assigned due to error."} -------------------------------------------------------------------------------- /backend/ai_engine/agents/report_agent.py: -------------------------------------------------------------------------------- 1 | # from langchain_community.chat_models import ChatOpenAI 2 | from langchain_groq import ChatGroq 3 | from langchain.prompts import ChatPromptTemplate 4 | from langchain.output_parsers import PydanticOutputParser 5 | from langchain.schema import HumanMessage, SystemMessage 6 | from pydantic import BaseModel, Field 7 | from typing import List, Dict, Any 8 | from backend.ai_engine.rag.retriever import Retriever 9 | from dotenv import load_dotenv 10 | import os 11 | import re 12 | import json 13 | from datetime import datetime 14 | 15 | load_dotenv() 16 | 17 | class ReportOutput(BaseModel): 18 | summary: str = Field(description="Summary of the project status, including tasks and assigned team members") 19 | key_metrics: Dict[str, float] = Field(description="Key metrics of the project") 20 | risks: List[str] = Field(description="Identified risks in the project") 21 | recommendations: List[str] = Field(description="List of recommendations for project improvement") 22 | 23 | class ReportAgent: 24 | def __init__(self, retriever: Retriever, model_name: str = "gpt-3.5-turbo"): 25 | self.llm = ChatGroq( 26 | groq_api_key=os.getenv("GROQ_API_KEY"), 27 | model="mixtral-8x7b-32768", 28 | temperature=0, 29 | max_tokens=None, 30 | timeout=None, 31 | max_retries=2, 32 | ) 33 | self.parser = PydanticOutputParser(pydantic_object=ReportOutput) 34 | self.retriever = retriever 35 | self.report_prompt = ChatPromptTemplate.from_template( 36 | "Generate a project report based on the following information:\n" 37 | "Tasks: {tasks}\n" 38 | "Project context: {project_context}\n" 39 | "Similar past projects: {similar_projects}\n" 40 | "Please include in the summary section a list of tasks with their assigned team members (if available).\n" 41 | "{format_instructions}" 42 | ) 43 | 44 | def generate_report(self, tasks: List[Dict[str, Any]]) -> Dict[str, Any]: 45 | if not tasks: 46 | return { 47 | "summary": "No tasks available for report generation.", 48 | "key_metrics": {}, 49 | "risks": ["No tasks to analyze risks."], 50 | "recommendations": ["Start by adding tasks to the project."] 51 | } 52 | 53 | project_id = tasks[0].get('project_id') 54 | project_context = self.retriever.get_project_context(project_id) if project_id else {} 55 | similar_projects = self.retriever.get_similar_projects(project_id) if project_id else [] 56 | 57 | # Convert datetime objects to strings 58 | def json_serial(obj): 59 | if isinstance(obj, datetime): 60 | return obj.isoformat() 61 | raise TypeError(f"Type {type(obj)} not serializable") 62 | 63 | # Enhance task information with team members if available in project context 64 | team_members = project_context.get('team_members', []) 65 | for task in tasks: 66 | task['assigned_to'] = team_members[task['id'] % len(team_members)] if team_members else "Unassigned" 67 | 68 | system_message = SystemMessage(content="You are an AI assistant tasked with generating project reports.") 69 | human_message = HumanMessage(content=self.report_prompt.format( 70 | tasks=json.dumps(tasks, default=json_serial, indent=2), 71 | project_context=json.dumps(project_context, default=json_serial, indent=2), 72 | similar_projects=json.dumps(similar_projects, default=json_serial, indent=2), 73 | format_instructions=self.parser.get_format_instructions() 74 | )) 75 | 76 | messages = [system_message, human_message] 77 | 78 | try: 79 | response = self.llm.invoke(messages) 80 | report_info = self.parser.parse(response.content) 81 | return report_info.dict() 82 | except Exception as e: 83 | print(f"Error in generate_report: {e}") 84 | return { 85 | "summary": "An error occurred while generating the report.", 86 | "key_metrics": {}, 87 | "risks": ["Unable to analyze risks due to an error."], 88 | "recommendations": ["Please try again or contact support if the issue persists."] 89 | } -------------------------------------------------------------------------------- /frontend/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 |${result.summary}
334 |