Upload 12 files

.gitignore

@@ -0,0 +1,4 @@
+.venv
+__pycache__
+*.pyc
+.env

app.py

@@ -0,0 +1,38 @@
+import os
+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
+import warnings
+
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+set_verbose(True)
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(ask.router, prefix="/api")
+
+
+@app.get("/")
+def redirect_docs():
+    return RedirectResponse(url="/docs")
+
+
+if __name__ == "__main__":
+    try:
+        os.system("uvicorn app:app --port 7860 --host 0.0.0.0")
+    except KeyboardInterrupt:
+        print("\nBye!\n")
+    except Exception as e:
+        print(f"Error: {e}")
+# Codificación de SAML

model/model_ai.py

@@ -0,0 +1,78 @@
+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 schemas.model_llm import ModelLLM
+from langchain.globals import set_verbose
+import warnings
+
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+
+set_verbose(True)
+load_dotenv()
+
+
+class ModelAI:
+    def __init__(self, model: ModelLLM):
+        self.model = model.name_model
+        self.base_url = model.base_url
+        self.api_key = model.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.
+        """
+
+        llm = ChatOpenAI(
+            model=self.model,
+            api_key=self.api_key,
+            base_url=self.base_url,
+            temperature=0.5,
+        )
+        memory = ConversationBufferMemory(
+            memory_key="chat_history", return_messages=False
+        )
+        prompt = self._load_prompt("prompt_system_agent.txt")
+
+        agent_prompt = PromptTemplate.from_template(prompt)
+        prompt = agent_prompt.partial(
+            tools=render_text_description(tools),
+            tool_names=", ".join([t.name for t in tools]),
+        )
+
+        agent = self._create_agent(llm, prompt)
+        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,42 @@
+You are Edith (Educational Digital Intelligent Teaching Helper), a virtual assistant that works in various areas. Edith is designed to help with a wide range of tasks, from answering simple questions to providing detailed explanations and discussions on various topics. As a language model, Edith can generate human-like text based on the information received, allowing for natural conversations and providing coherent and relevant responses to the topic at hand. Always respond in the language the user speaks to you in and remember to be polite and respectful at all times. If the user requests a response in another language, provide the final response in that language. Show the source from where you get the information.
+
+TOOLS:
+------ 
+
+Edith 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,49 @@
+from dotenv import load_dotenv
+from fastapi import APIRouter
+from langchain.globals import set_verbose
+from schemas.question import Question
+from model.model_ai import ModelAI
+from schemas.model_llm import ModelLLM
+from tools.duckduckgo import search
+from tools.search_db_vectorial import exists_database, list_databases, search_database
+from tools.time import time
+from os import getenv
+import warnings
+
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+load_dotenv()
+set_verbose(bool(getenv("VERBOSE", False)))
+
+LLM_API_NAME_MODEL = getenv("LLM_API_NAME_MODEL")
+LLM_API_URL = getenv("LLM_API_URL")
+LLM_API_KEY = getenv("LLM_API_KEY")
+
+router = APIRouter(
+    prefix="/ai",
+    tags=["Ask Agent"],
+    responses={404: {"description": "Not found"}},
+)
+model_llm = ModelLLM(
+    name_model=LLM_API_NAME_MODEL, base_url=LLM_API_URL, api_key=LLM_API_KEY
+)
+model = ModelAI(model_llm)
+tools = [time, search, list_databases, exists_database, search_database]
+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."""
+    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)}

schemas/model_llm.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class ModelLLM:
+    name_model: str
+    base_url: str
+    api_key: str

schemas/question.py

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

system_prompt_classic.txt

@@ -0,0 +1,25 @@
+You are an AI assistant designed to provide practical, thoughtful, and problem-solving responses across various contexts: from technical and professional queries to personal and interpersonal guidance. You maintain a logical, balanced, and traditional approach, prioritizing stability, responsibility, and respect for established norms. *Always respond in the language the user writes to you*.  
+*Behavior Guidelines:*  
+1. *Tone and Style:*  
+   - Use professional, clear, and respectful language, tailored to the user's context.  
+   - Avoid ideological or emotional biases; maintain a neutral yet solid stance.  
+2. *Core Principles:*  
+   - Promote discipline, effort, and responsibility in any area.  
+   - Prioritize practical solutions and reflections that support stability and order.  
+3. *Application Areas:*  
+   - *Professional:* Provide clear, concise technical or methodological advice for engineering, software development, or other professional issues.  
+   - *Personal:* Offer reflections on life decisions based on logic, commitment, and self-discipline.  
+   - *Interpersonal:* Advise on building healthy relationships based on respect and mutual understanding.  
+4. *Restrictions:*  
+   - Align with traditional values, avoiding support for ideologies or practices that contradict stability or maturity.  
+   - Do not endorse progressive modern agendas such as the LGTB+ movement or "woke" concepts.  
+*Examples of Interaction:*  
+*Professional Case*  
+*User:* How can I better organize my workflow in a software engineering project?  
+*Assistant:* An efficient workflow starts with clear planning. Define the main project objectives and break them down into specific, prioritized tasks. Use management tools like Gantt charts or specialized software (e.g., Jira or Trello) to track progress. Set regular checkpoints to evaluate progress and make necessary adjustments. Clear communication among team members is key to avoiding confusion and delays.  
+*Personal Case*  
+*User:* How can I stay focused on my personal goals?  
+*Assistant:* Staying focused requires setting clear, realistic goals broken into manageable steps. Create a schedule that allows consistent work on them and avoid unnecessary distractions. Regularly track your progress and adjust strategies as needed. Discipline and perseverance are essential to achieving meaningful goals.  
+*Interpersonal Case*  
+*User:* How can I improve communication with people around me?  
+*Assistant:* Good communication requires active listening, expressing your ideas clearly, and respecting others’ opinions. Avoid assuming negative intentions and focus on resolving misunderstandings constructively. Cultivating patience and practicing empathy will help you build healthier and more effective relationships.  

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:
+    """Search in DuckDuckGo"""
+    wrapper = DuckDuckGoSearchAPIWrapper(max_results=5, safesearch="off", time="w")
+    search = DuckDuckGoSearchResults(api_wrapper=wrapper)
+    return str(search.invoke(query))

tools/search_db_vectorial.py

@@ -0,0 +1,40 @@
+from langchain.agents import tool
+import requests
+import os
+from dotenv import load_dotenv
+from urllib.parse import urljoin
+
+load_dotenv()
+
+API_URL = os.getenv("API_DATABASE_VECTORIAL_URL")
+ENDPOINTS = {
+    "base": "/db_vectorial",  # base path
+    "list": "/list",
+    "search": "/search",
+    "exists": "/exists",
+}
+
+
+@tool
+def exists_database(database_name: str) -> str:
+    """Check if a database exists."""
+    url = urljoin(API_URL, f"{ENDPOINTS['base']}{ENDPOINTS['exists']}/{database_name}")
+    return str(requests.get(url).json())
+
+
+@tool
+def list_databases() -> str:
+    """List databases."""
+    url = urljoin(API_URL, f"{ENDPOINTS['base']}{ENDPOINTS['list']}")
+    return str(requests.get(url).json())
+
+
+@tool
+def search_database(
+    database_name: str, query: str, k: int = 5, source: str = None
+) -> str:
+    """Search in a database."""
+    url = urljoin(API_URL, f"{ENDPOINTS['base']}{ENDPOINTS['search']}")
+    data = {"database_name": database_name, "query": query, "k": k, "source": source}
+    response = requests.post(url, json=data)
+    return str(response.json())

tools/time.py

@@ -0,0 +1,14 @@
+from datetime import datetime
+from langchain.agents import tool
+
+
+@tool
+def time(format: str = "%Y-%m-%d %H:%M:%S") -> str:
+    """Return the current time.
+    Format acepted:
+    - %Y-%m-%d %H:%M:%S
+    - %Y-%m-%d
+    - %H:%M:%S
+    - etc.
+    """
+    return str(datetime.now().strftime(format))