Upload 9 files

Dockerfile

@@ -0,0 +1,15 @@
+# Usa una imagen base de Python
+FROM python:3.9
+# Establece el directorio de trabajo
+WORKDIR /code
+
+# Copia los archivos necesarios al contenedor
+COPY ./requirements.txt /code/requirements.txt
+RUN pip install --no-cache-dir -r /code/requirements.txt
+
+COPY . .
+
+RUN chmod -R 777 /code
+
+# Comando para ejecutar la aplicación
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,31 @@
+from fastapi import FastAPI
+from fastapi.responses import RedirectResponse
+from langchain.globals import set_verbose
+from fastapi.middleware.cors import CORSMiddleware
+from routers import ask
+
+set_verbose(True)  # esto es la depuración de langchain
+
+app = FastAPI()  # esto es la instancia de FastAPI
+
+# CORS
+app.add_middleware(  # esto es el middleware de CORS
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/")  # esto es la ruta raíz
+async def redirect_to_docs():
+    return RedirectResponse(url="/docs")
+
+
+app.include_router(ask.router, prefix="/api")  # esto es el enrutador de la API
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app, host="0.0.0.0", port=7860)

controller/question.py

@@ -0,0 +1,5 @@
+from pydantic import BaseModel
+
+
+class Question(BaseModel):
+    input: str

model/model_ai.py

@@ -0,0 +1,76 @@
+import os
+from typing import Sequence
+from dotenv import load_dotenv
+from langchain_core.tools import BaseTool
+from langchain_openai import ChatOpenAI
+from langchain.memory import ConversationBufferMemory
+from langchain_core.prompts.prompt import PromptTemplate
+from langchain.tools.render import render_text_description
+from langchain.agents.output_parsers import ReActSingleInputOutputParser
+from langchain.agents import AgentExecutor
+from langchain.agents.format_scratchpad import format_log_to_str
+
+from langchain.globals import set_verbose
+
+set_verbose(True)  # Mensajes de depuración desactivados
+
+
+class ModelAI:
+    def __init__(self):
+        load_dotenv()
+        self.model = "deepseek-chat"
+        self.base_url = "https://api.deepseek.com"
+        self.api_key = os.getenv("DEEPSEEK_API_KEY")
+
+    def agent_executer(self, tools: Sequence[BaseTool]) -> AgentExecutor:
+        """
+        Create an agent executor with the given tools and the model.
+
+        Args:
+            tools: A sequence of tools to be used by the agent.
+
+        Returns:
+            An agent executor with the given tools and the model.
+        """
+        # definición del modelo llm
+        llm = ChatOpenAI(
+            model=self.model,
+            api_key=self.api_key,
+            base_url=self.base_url,
+            temperature=0.5,
+        )
+        # añadir memoria
+        memory = ConversationBufferMemory(memory_key="chat_history")
+        # cargar instrucciones del sistema
+        prompt = self._load_prompt("prompt_system_agent.txt")
+        # añadir herramientas a las instrucciones del sistema
+        agent_prompt = PromptTemplate.from_template(prompt)
+        prompt = agent_prompt.partial(
+            tools=render_text_description(tools),
+            tool_names=", ".join([t.name for t in tools]),
+        )
+        # crear agente que es la suma de las instrucciones del sistema y el modelo llm
+        agent = self._create_agent(llm, prompt)
+        # devolver el agente ejecutor
+        return AgentExecutor(agent=agent, tools=tools, memory=memory)
+
+    @staticmethod
+    def _load_prompt(filepath: str) -> str:
+        with open(filepath, "r") as file:
+            return file.read()
+
+    @staticmethod
+    def _create_agent(llm: ChatOpenAI, prompt: PromptTemplate) -> dict:
+        llm_with_stop = llm.bind(stop=["\nObservation"])
+        return (
+            {
+                "input": lambda x: x["input"],
+                "agent_scratchpad": lambda x: format_log_to_str(
+                    x["intermediate_steps"]
+                ),
+                "chat_history": lambda x: x["chat_history"],
+            }
+            | prompt
+            | llm_with_stop
+            | ReActSingleInputOutputParser()
+        )

prompt_system_agent.txt

@@ -0,0 +1,83 @@
+Responde en el idioma: Español
+You are ReqGen (Requirement Generator), a specialized virtual assistant designed to assist in the generation of functional and non-functional requirements for software development projects. ReqGen is equipped with advanced natural language processing capabilities to understand and interpret user inputs, ensuring that the generated requirements are clear, precise, and aligned with the project's objectives.
+
+# Proposed Standard for Requirement Definition
+
+ 1. Functional Requirements (FR)
+Description: Detail what the system must do to meet the project's objectives. They focus on visible functionalities for the user or essential internal operations.
+- Rules for Defining FR:
+  1. Clear and Objective Name: Each FR must have a unique identifier (FR-01, FR-02, etc.) and a representative title.
+  2. Action-Oriented: Use infinitives, such as "Allow", "Register", "Display".
+  3. Measurable and Verifiable: Define expected outcomes or clear acceptance criteria.
+  4. Avoid Ambiguities: Use specific terms instead of expressions like "fast", "better".
+  5. User Focus: Include, when relevant, the main actor of the requirement.
+Example:
+- FR-01: Register Users.
+  - The system must allow new users to register by providing a name, email, and password.
+
+ 2. Non-Functional Requirements (NFR)
+Description: Describe how the system should behave. They are not related to specific functions but to general characteristics such as performance, usability, and security.
+- Rules for Defining NFR:
+  1. Representative and Unique Name: Each NFR must have a unique identifier (NFR-01, NFR-02, etc.).
+  2. Focused on "How": Detail quality attributes, technical or environmental constraints.
+  3. Measurable Criteria: Include specific values (e.g., "response time less than 3 seconds").
+  4. Categorized: Group NFR by attributes such as performance, availability, scalability, etc.
+Example:
+- NFR-01: Performance.
+  - The system must respond to user requests in less than 2 seconds for 95% of queries made.
+
+# Common Categories
+ Functional Requirements
+- System functions.
+- User flows.
+- Business rules.
+- Integrations with other systems.
+
+ Non-Functional Requirements
+- Performance: Response time, processing speed.
+- Scalability: Capacity to support an increase in users or data.
+- Security: Authentication, authorization, encryption.
+- Compatibility: Supported platforms and browsers.
+- Usability: Ease of use, accessibility.
+- Availability: Guaranteed uptime.
+
+TOOLS:
+------ 
+
+ReqGen has access to the following tools: 
+
+{tools} 
+
+To use a tool, please use the following format: 
+
+``` 
+
+Thought: Do I need to use a tool? Yes 
+
+Action: the action to take, should be one of [{tool_names}] 
+
+Action Input: the input to the action 
+
+Observation: the result of the action 
+
+``` 
+
+When you have a response to say to the Human, or if you do not need to use a tool, you MUST use the format: 
+
+``` 
+
+Thought: Do I need to use a tool? No 
+
+Final Answer: [your response here] 
+
+``` 
+
+Begin! 
+
+Previous conversation history: 
+
+{chat_history} 
+
+New input: {input} 
+
+{agent_scratchpad}

requirements.txt

@@ -0,0 +1,14 @@
+requests 
+fastapi 
+langchain 
+langchain-core 
+langchain-openai 
+langchain-community 
+langchain-huggingface
+faiss-cpu 
+duckduckgo-search
+uvicorn
+einops
+python-multipart
+docx2txt
+aiofiles

routers/ask.py

@@ -0,0 +1,36 @@
+from fastapi import APIRouter
+from langchain.globals import set_verbose
+from controller.question import Question
+from model.model_ai import ModelAI
+from tools.duckduckgo import search
+from tools.time import time
+
+set_verbose(True)  # Mensajes de depuración desactivados
+
+router = APIRouter(
+    prefix="/IA",
+    tags=["Ask Agent"],
+    responses={404: {"description": "No encontrado"}},
+)
+model = ModelAI()
+# Se añade las herramientas de tiempo y búsqueda al agente
+tools = [time, search]
+# esto incluye el uso de llm + memoria + herramientas
+agent_executor = model.agent_executer(tools)
+
+
+@router.get("/ask")
+def ask_question():
+    """Devuelve el formato de pregunta esperado."""
+    return {"input": "Pregunta"}
+
+
+@router.post("/ask")
+async def ask_question(question: Question):
+    """Recibe una pregunta y devuelve una respuesta del agente ejecutor."""
+    try:
+        # Usamos ainvoke para realizar la llamada asíncrona
+        respuesta = await agent_executor.ainvoke({"input": question.input})
+        return {"respuesta": respuesta["output"]}
+    except Exception as e:
+        return {"error": str(e)}

tools/duckduckgo.py

@@ -0,0 +1,11 @@
+from langchain_community.utilities import DuckDuckGoSearchAPIWrapper
+from langchain_community.tools import DuckDuckGoSearchResults
+from langchain.agents import tool
+
+
+@tool
+def search(query: str) -> str:
+    """Búsqueda en DuckDuckGo."""
+    wrapper = DuckDuckGoSearchAPIWrapper(max_results=10, safesearch="off", time="w")
+    search = DuckDuckGoSearchResults(api_wrapper=wrapper)
+    return str(search.invoke(query))

tools/time.py

@@ -0,0 +1,19 @@
+from datetime import datetime
+from langchain.agents import tool
+
+
+@tool
+def time(format: str = "%Y-%m-%d %H:%M:%S") -> str:
+    """
+    Returns the current system time as a formatted string.
+
+    Args:
+        format (str): The format for the output time string. Default is "%Y-%m-%d %H:%M:%S".
+
+    Returns:
+        str: The current system time in the specified format.
+    """
+
+    current_time = datetime.now().strftime(format)
+    print(f"Current system time: {current_time}")
+    return current_time