@qubiit/lmagent 2.5.0

package/templates/agent-python/agent.py

@@ -0,0 +1,272 @@
+"""
+Agent implementation template.
+
+This is the main agent class that you can customize for your specific use case.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import Any
+
+import yaml
+import structlog
+from pydantic import BaseModel
+
+# Importar desde LMAgent (ajustar paths según estructura real)
+# from lmagent.core.base_agent import BaseAgent
+# from lmagent.core.tool_registry import ToolRegistry
+# from lmagent.core.llm_provider import get_provider
+# from lmagent.core.trajectory import TrajectoryLogger
+# from lmagent.core.cost_tracker import CostTracker
+
+logger = structlog.get_logger()
+
+
+class AgentConfig(BaseModel):
+    """Configuration for the agent."""
+    name: str
+    display_name: str
+    description: str
+    version: str = "1.0.0"
+    
+    # LLM config
+    llm_provider: str = "openai"
+    llm_model: str = "gpt-4o"
+    temperature: float = 0.7
+    max_tokens: int = 4096
+    
+    # Limits
+    max_iterations: int = 10
+    max_cost: float = 2.00
+    timeout_seconds: int = 300
+    
+    # Tools
+    tools: list[str] = []
+    
+    @classmethod
+    def from_yaml(cls, path: str | Path) -> "AgentConfig":
+        """Load config from YAML file."""
+        with open(path) as f:
+            data = yaml.safe_load(f)
+        
+        return cls(
+            name=data["name"],
+            display_name=data["display_name"],
+            description=data["description"],
+            version=data.get("version", "0.1.0"),
+            llm_provider=data.get("llm", {}).get("provider", "openai"),
+            llm_model=data.get("llm", {}).get("model", "gpt-4o"),
+            temperature=data.get("llm", {}).get("temperature", 0.7),
+            max_tokens=data.get("llm", {}).get("max_tokens", 4096),
+            max_iterations=data.get("limits", {}).get("max_iterations", 10),
+            max_cost=data.get("limits", {}).get("max_cost", 2.00),
+            timeout_seconds=data.get("limits", {}).get("timeout_seconds", 300),
+            tools=data.get("tools", {}).get("from_registry", []),
+        )
+
+
+class MyAgent:
+    """
+    Custom agent implementation.
+    
+    This agent [describe what your agent does].
+    
+    Example:
+        >>> agent = MyAgent.from_config("config.yaml")
+        >>> result = await agent.run("Your input here")
+        >>> print(result)
+    """
+    
+    def __init__(self, config: AgentConfig):
+        """Initialize the agent with configuration."""
+        self.config = config
+        self.history: list[dict[str, Any]] = []
+        self.iteration_count = 0
+        self.total_cost = 0.0
+        
+        # Load system prompt
+        self.system_prompt = self._load_system_prompt()
+        
+        # Initialize tools
+        self.tools = self._load_tools()
+        
+        # Initialize LLM provider
+        # self.llm = get_provider(config.llm_provider, config.llm_model)
+        
+        # Initialize tracking
+        # self.trajectory = TrajectoryLogger()
+        # self.cost_tracker = CostTracker(max_cost=config.max_cost)
+        
+        logger.info(
+            "agent_initialized",
+            name=config.name,
+            model=config.llm_model,
+            tools=list(self.tools.keys())
+        )
+    
+    @classmethod
+    def from_config(cls, config_path: str | Path) -> "MyAgent":
+        """Create agent from config file."""
+        config = AgentConfig.from_yaml(config_path)
+        return cls(config)
+    
+    def _load_system_prompt(self) -> str:
+        """Load system prompt from file."""
+        prompt_path = Path(__file__).parent / "prompts" / "system.md"
+        if prompt_path.exists():
+            return prompt_path.read_text()
+        return "You are a helpful AI assistant."
+    
+    def _load_tools(self) -> dict[str, Any]:
+        """Load and initialize tools."""
+        tools = {}
+        
+        # Load tools from registry
+        # for tool_name in self.config.tools:
+        #     tools[tool_name] = ToolRegistry.get(tool_name)
+        
+        # Load custom tools
+        # from .tools import custom_tool
+        # tools["custom_tool"] = custom_tool.CustomTool()
+        
+        return tools
+    
+    async def run(
+        self,
+        user_input: str,
+        context: dict[str, Any] | None = None
+    ) -> str:
+        """
+        Run the agent with user input.
+        
+        Args:
+            user_input: The user's query or task.
+            context: Optional additional context.
+        
+        Returns:
+            The agent's final response.
+        
+        Raises:
+            CostLimitExceeded: If the cost limit is reached.
+            MaxIterationsExceeded: If max iterations is reached.
+        """
+        logger.info(
+            "agent_run_start",
+            input_length=len(user_input),
+            context_keys=list(context.keys()) if context else []
+        )
+        
+        # Add user message to history
+        self.history.append({
+            "role": "user",
+            "content": user_input
+        })
+        
+        # Main agent loop
+        for iteration in range(self.config.max_iterations):
+            self.iteration_count = iteration + 1
+            
+            logger.info(f"🤠 INFO ========================= STEP {iteration + 1} =========================")
+            
+            # Get LLM response
+            # response = await self.llm.complete(
+            #     system_prompt=self.system_prompt,
+            #     messages=self.history,
+            #     tools=self.tools,
+            #     temperature=self.config.temperature,
+            #     max_tokens=self.config.max_tokens
+            # )
+            
+            # For template purposes, simulate a response
+            response = await self._simulate_response(user_input, iteration)
+            
+            # Track cost
+            # self.cost_tracker.track(
+            #     model=self.config.llm_model,
+            #     input_tokens=response.usage.input_tokens,
+            #     output_tokens=response.usage.output_tokens
+            # )
+            
+            # Log thinking
+            if hasattr(response, 'thinking'):
+                logger.info(f"💭 THOUGHT: {response.thinking}")
+            
+            # If there are tool calls, execute them
+            if hasattr(response, 'tool_calls') and response.tool_calls:
+                for tool_call in response.tool_calls:
+                    logger.info(f"🎬 ACTION: {tool_call.name}({tool_call.args})")
+                    
+                    # Execute tool
+                    # result = await self.tools[tool_call.name].execute(**tool_call.args)
+                    result = {"success": True, "data": "Simulated result"}
+                    
+                    logger.info(f"📤 OBSERVATION: {str(result)[:200]}...")
+                    
+                    # Add to history
+                    self.history.append({
+                        "role": "tool",
+                        "name": tool_call.name,
+                        "result": result
+                    })
+            else:
+                # No tool calls, agent wants to respond
+                final_response = response.content if hasattr(response, 'content') else str(response)
+                
+                self.history.append({
+                    "role": "assistant",
+                    "content": final_response
+                })
+                
+                logger.info(
+                    "agent_run_complete",
+                    iterations=self.iteration_count,
+                    cost=self.total_cost
+                )
+                
+                return final_response
+        
+        # Max iterations reached
+        logger.warning("agent_max_iterations_reached")
+        return "I've reached my maximum number of steps. Here's what I've accomplished so far..."
+    
+    async def _simulate_response(self, user_input: str, iteration: int) -> Any:
+        """Simulate a response for template testing."""
+        # This is a placeholder. In real implementation,
+        # this would be replaced by actual LLM calls.
+        
+        class SimulatedResponse:
+            thinking = f"Processing iteration {iteration + 1}..."
+            content = f"This is a simulated response to: {user_input}"
+            tool_calls = [] if iteration > 0 else []  # No tools in simulation
+        
+        await asyncio.sleep(0.1)  # Simulate API latency
+        return SimulatedResponse()
+    
+    def get_trajectory(self) -> list[dict[str, Any]]:
+        """Get the full trajectory of the agent run."""
+        return self.history.copy()
+    
+    def get_cost(self) -> float:
+        """Get the total cost of the agent run."""
+        return self.total_cost
+
+
+# Example usage
+async def main():
+    """Example of how to use the agent."""
+    # Load agent from config
+    agent = MyAgent.from_config("config.yaml")
+    
+    # Run agent
+    result = await agent.run("What is the weather like today?")
+    print(f"Result: {result}")
+    
+    # Get metrics
+    print(f"Iterations: {agent.iteration_count}")
+    print(f"Cost: ${agent.get_cost():.4f}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/templates/agent-python/config.yaml

@@ -0,0 +1,76 @@
+# Agent Configuration
+# Template de configuración para un agente LMAgent
+
+# Información básica
+name: "my_agent"
+display_name: "My Agent"
+description: "Descripción de lo que hace el agente"
+version: "0.1.0"
+
+# Configuración de LLM
+llm:
+  provider: "openai"          # openai, anthropic, google
+  model: "gpt-4o"             # Modelo específico
+  temperature: 0.7            # 0-1, más bajo = más determinístico
+  max_tokens: 4096            # Máximo de tokens por respuesta
+
+# Límites
+limits:
+  max_iterations: 10          # Máximo de pasos del agente
+  max_cost: 2.00              # USD máximo por ejecución
+  timeout_seconds: 300        # Timeout total
+
+# System prompt
+system_prompt:
+  file: "prompts/system.md"   # Archivo con el prompt
+  # O inline:
+  # content: |
+  #   You are an AI assistant...
+
+# Herramientas disponibles
+tools:
+  # Herramientas del registry global
+  from_registry:
+    - http_request
+    - file_read
+    - file_write
+    - file_search
+  
+  # Herramientas custom locales
+  custom:
+    - module: "tools.custom_tool"
+      class: "CustomTool"
+
+# Guardrails
+guardrails:
+  # Herramientas que requieren confirmación
+  require_confirmation:
+    - file_write
+    - http_request
+  
+  # Acciones bloqueadas
+  blocked_actions: []
+  
+  # Patrones de código peligrosos a bloquear
+  dangerous_patterns:
+    - "rm -rf"
+    - "DROP TABLE"
+
+# Logging
+logging:
+  level: "INFO"               # DEBUG, INFO, WARNING, ERROR
+  trajectory: true            # Guardar trajectory completo
+  cost_tracking: true         # Trackear costos
+
+# Variables de entorno requeridas
+required_env:
+  - OPENAI_API_KEY            # API key del proveedor LLM
+  # - CUSTOM_API_KEY          # Agregar variables custom
+
+# Metadata
+metadata:
+  author: "Tu Nombre"
+  created_at: "2024-01-01"
+  tags:
+    - "automation"
+    - "ai-agent"

package/templates/agent-python/prompts/system.md

@@ -0,0 +1,109 @@
+You are {agent_name}, an AI assistant specialized in {domain}.
+
+## Your Role
+
+{Describe the role and responsibilities of this agent}
+
+## Available Tools
+
+You have access to the following tools:
+
+### http_request
+Make HTTP requests to external APIs. Use when you need to fetch data from or send data to external services.
+
+Parameters:
+- url (required): Full URL to request
+- method (optional): HTTP method (GET, POST, PUT, DELETE). Default: GET
+- headers (optional): Request headers
+- body (optional): Request body for POST/PUT
+
+### file_read
+Read contents of files in the project.
+
+Parameters:
+- path (required): Relative path to the file
+- start_line (optional): Starting line number
+- end_line (optional): Ending line number
+
+### file_write
+Write or modify files in the project.
+
+Parameters:
+- path (required): Relative path to the file
+- content (required): Content to write
+- mode (optional): overwrite, append, or insert. Default: overwrite
+
+### file_search
+Search for patterns in project files.
+
+Parameters:
+- pattern (required): Search pattern (regex supported)
+- path (optional): Directory to search in. Default: "."
+- include (optional): File patterns to include
+- exclude (optional): File patterns to exclude
+
+## How to Use Tools
+
+When you need to take an action:
+
+1. **Think first**: Consider which tool is most appropriate for the task
+2. **Call the tool**: Provide all required parameters
+3. **Wait for observation**: The tool will return a result
+4. **Iterate or respond**: Based on the result, decide next steps
+
+## Response Guidelines
+
+- Be concise and direct in your responses
+- When using data from tools, mention the source
+- If a tool fails, explain what happened and try an alternative approach
+- If you cannot complete a task, explain why clearly
+- Structure complex responses with headings and bullet points
+
+## Constraints
+
+- Maximum cost per session: $2.00
+- Maximum iterations: 10
+- Do not access files outside the project directory
+- Do not make changes to production systems without explicit confirmation
+- Always validate input data before processing
+
+## Examples
+
+### Example 1: Finding information in files
+
+User: "Find all functions that handle user authentication"
+
+Thinking: I need to search for authentication-related code in the project.
+
+Action: file_search(pattern="def.*auth|login|authenticate", include=["*.py"])
+
+Observation: Found 5 matches in 3 files...
+
+Response: "I found authentication-related functions in the following files:
+1. `app/auth/service.py` - `authenticate_user()`, `validate_token()`
+2. `app/routers/auth.py` - `login()`, `logout()`
+3. `app/core/security.py` - `verify_password()`"
+
+### Example 2: Making an API request
+
+User: "Check if the external API is responding"
+
+Thinking: I need to make a health check request to the external API.
+
+Action: http_request(url="https://api.example.com/health", method="GET")
+
+Observation: {"status": "healthy", "version": "1.2.3"}
+
+Response: "The external API is responding correctly. Status: healthy, Version: 1.2.3"
+
+## Output Format
+
+When presenting findings or results:
+
+1. **Summary**: Brief overview of what was found/done
+2. **Details**: Structured breakdown with specifics
+3. **Next Steps**: If applicable, suggest follow-up actions
+
+---
+
+Remember: You are here to help the user accomplish their tasks efficiently and accurately. Always prioritize clarity and correctness over speed.

package/templates/agent-python/requirements.txt

@@ -0,0 +1,7 @@
+pydantic>=2.0.0
+PyYAML>=6.0
+structlog>=24.1.0
+python-dotenv>=1.0.0
+openai>=1.0.0
+# Add other provider SDKs as needed
+# anthropic>=0.3.0

package/templates/automation-n8n/README.md

@@ -0,0 +1,14 @@
+# LMAgent n8n Automation Template
+
+Template básico para flujos de automatización con n8n.
+
+## Contenido
+
+- `webhook-handler.json`: Un flujo simple que recibe un webhook y devuelve una respuesta JSON formateada.
+
+## Cómo usar
+
+1. Abre tu instancia de n8n.
+2. Crea un nuevo workflow.
+3. Ve a "Import from File" o copia el contenido del JSON y pégalo directamente en el canvas (Ctrl+V).
+4. Activa el workflow y prueba la URL del webhook de prueba.

package/templates/automation-n8n/webhook-handler.json

@@ -0,0 +1,57 @@
+{
+    "name": "LMAgent Webhook Handler",
+    "nodes": [
+        {
+            "parameters": {
+                "path": "webhook",
+                "responseMode": "lastNode",
+                "options": {}
+            },
+            "name": "Webhook",
+            "type": "n8n-nodes-base.webhook",
+            "typeVersion": 1,
+            "position": [
+                460,
+                300
+            ]
+        },
+        {
+            "parameters": {
+                "keepOnlySet": true,
+                "values": {
+                    "string": [
+                        {
+                            "name": "message",
+                            "value": "Hello from LMAgent Automation!"
+                        },
+                        {
+                            "name": "timestamp",
+                            "value": "={{ $now }}"
+                        }
+                    ]
+                },
+                "options": {}
+            },
+            "name": "Format Response",
+            "type": "n8n-nodes-base.set",
+            "typeVersion": 2,
+            "position": [
+                680,
+                300
+            ]
+        }
+    ],
+    "connections": {
+        "Webhook": {
+            "main": [
+                [
+                    {
+                        "node": "Format Response",
+                        "type": "main",
+                        "index": 0
+                    }
+                ]
+            ]
+        }
+    }
+}

package/templates/backend-node/Dockerfile

@@ -0,0 +1,12 @@
+FROM node:18-alpine
+
+WORKDIR /app
+
+COPY package*.json ./
+RUN npm install
+
+COPY . .
+RUN npm run build
+
+EXPOSE 3000
+CMD ["npm", "start"]

package/templates/backend-node/README.md

@@ -0,0 +1,15 @@
+# LMAgent Backend Node Template
+
+Template básico para backend con Node.js, Express y TypeScript.
+
+## Estructura
+
+- `src/`: Código fuente
+- `dist/`: Código compilado
+- `Dockerfile`: Configuración para despliegue
+
+## Scripts
+
+- `npm run dev`: Ejecuta en modo desarrollo
+- `npm run build`: Compila el proyecto
+- `npm start`: Ejecuta la versión compilada

package/templates/backend-node/package.json

@@ -0,0 +1,30 @@
+{
+    "name": "lmagent-backend-node",
+    "version": "1.0.0",
+    "description": "LMAgent Node.js Backend Template",
+    "main": "dist/index.js",
+    "scripts": {
+        "start": "node dist/index.js",
+        "dev": "ts-node-dev --respawn --transpile-only src/index.ts",
+        "build": "tsc",
+        "lint": "eslint src/**/*.ts",
+        "format": "prettier --write src/**/*.ts"
+    },
+    "dependencies": {
+        "cors": "^2.8.5",
+        "dotenv": "^16.3.1",
+        "express": "^4.18.2",
+        "helmet": "^7.0.0",
+        "morgan": "^1.10.0"
+    },
+    "devDependencies": {
+        "@types/cors": "^2.8.13",
+        "@types/express": "^4.17.17",
+        "@types/morgan": "^1.9.4",
+        "@types/node": "^20.4.5",
+        "eslint": "^8.46.0",
+        "prettier": "^3.0.0",
+        "ts-node-dev": "^2.0.0",
+        "typescript": "^5.1.6"
+    }
+}

package/templates/backend-node/src/index.ts

@@ -0,0 +1,19 @@
+import express from 'express';
+import morgan from 'morgan';
+import helmet from 'helmet';
+import cors from 'cors';
+import { router } from './routes';
+
+const app = express();
+const port = process.env.PORT || 3000;
+
+app.use(morgan('dev'));
+app.use(helmet());
+app.use(cors());
+app.use(express.json());
+
+app.use('/api', router);
+
+app.listen(port, () => {
+    console.log(`Server is running at http://localhost:${port}`);
+});

package/templates/backend-node/src/routes.ts

@@ -0,0 +1,7 @@
+import { Router } from 'express';
+
+export const router = Router();
+
+router.get('/health', (req, res) => {
+    res.json({ status: 'ok', timestamp: new Date().toISOString() });
+});

package/templates/backend-node/tsconfig.json

@@ -0,0 +1,22 @@
+{
+    "compilerOptions": {
+        "target": "es2020",
+        "module": "commonjs",
+        "lib": [
+            "es2020"
+        ],
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "**/*.test.ts"
+    ]
+}

package/templates/backend-python/Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.11-slim
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY ./app /code/app
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]