memra 0.2.4__py3-none-any.whl → 0.2.5__py3-none-any.whl

memra/models.py

@@ -26,6 +26,7 @@ class Agent(BaseModel):
     allow_delegation: bool = False
     fallback_agents: Optional[Dict[str, str]] = None
     config: Optional[Dict[str, Any]] = None
+    custom_processing: Optional[Any] = None  # Function to call after tool execution
 
 class ExecutionPolicy(BaseModel):
     retry_on_fail: bool = True

memra/tool_registry_client.py

@@ -62,7 +62,7 @@ class ToolRegistryClient:
             }
             
             # Make API call
-            with httpx.Client(timeout=120.0) as client:  # Longer timeout for tool execution
+            with httpx.Client(timeout=60.0) as client:  # Reduced timeout for faster response
                 response = client.post(
                     f"{self.api_base}/tools/execute",
                     headers={
@@ -81,7 +81,7 @@ class ToolRegistryClient:
             logger.error(f"Tool {tool_name} execution timed out")
             return {
                 "success": False,
-                "error": f"Tool execution timed out after 120 seconds"
+                "error": f"Tool execution timed out after 60 seconds"
             }
         except httpx.HTTPStatusError as e:
             logger.error(f"API error for tool {tool_name}: {e.response.status_code}")

memra-0.2.5.dist-info/METADATA

@@ -0,0 +1,319 @@
+Metadata-Version: 2.4
+Name: memra
+Version: 0.2.5
+Summary: Declarative framework for enterprise workflows with MCP integration - Client SDK
+Home-page: https://github.com/memra/memra-sdk
+Author: Memra
+Author-email: Memra <support@memra.com>
+License: MIT
+Project-URL: Homepage, https://memra.co
+Project-URL: Repository, https://github.com/memra-platform/memra-sdk
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=1.8.0
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: typing-extensions>=4.0.0
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: aiohttp-cors>=0.7.0
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Provides-Extra: mcp
+Requires-Dist: psycopg2-binary>=2.9.0; extra == "mcp"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Memra SDK
+
+**The declarative framework for building enterprise-grade AI workflows with MCP integration.**
+
+[![PyPI version](https://badge.fury.io/py/memra.svg)](https://badge.fury.io/py/memra)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+
+## 🎯 Why Memra?
+
+Building AI-powered business workflows is hard. You need to:
+- **Orchestrate multiple AI agents** with different roles and responsibilities
+- **Integrate with external tools** (databases, APIs, file systems)
+- **Handle complex business logic** with validation and error recovery
+- **Scale from prototypes to production** without rewriting everything
+- **Maintain consistency** across different workflows and teams
+
+**Memra solves these challenges** by providing a declarative framework that lets you focus on *what* you want to accomplish, not *how* to wire everything together.
+
+## 🚀 Quick Start (5 minutes!)
+
+**Want to see Memra in action immediately?** Check out our [Quick Start Guide](QUICK_START.md) to run the ETL demo in minutes!
+
+### Installation
+
+```bash
+pip install memra
+```
+
+**📖 New to Memra?** For a complete beginner-friendly setup with step-by-step instructions, see our [Detailed Installation Guide](INSTALLATION_GUIDE.md) or run our automated setup script:
+
+```bash
+# Automated setup for new users
+bash scripts/setup_newbie.sh
+```
+
+**🔧 Repository Structure:** This repo uses git submodules with sparse checkout to provide minimal access to infrastructure and workflow templates while keeping private content secure.
+
+### Basic Example
+
+```python
+from memra import Agent, Department, LLM, ExecutionEngine
+
+# Define an agent
+agent = Agent(
+    role="Data Analyst",
+    job="Analyze customer data",
+    llm=LLM(model="llama-3.2-11b-vision-preview"),
+    sops=["Load data", "Perform analysis", "Generate report"],
+    output_key="analysis_result"
+)
+
+# Create a department
+department = Department(
+    name="Analytics",
+    mission="Provide data insights",
+    agents=[agent],
+    workflow_order=["Data Analyst"]
+)
+
+# Execute the workflow
+engine = ExecutionEngine()
+result = engine.execute_department(department, {"data": "customer_data.csv"})
+```
+
+## 🏗️ Core Architecture
+
+### Agent
+An AI worker that performs specific tasks using LLMs and tools. Agents have:
+- **Role**: What they do (e.g., "Data Analyst", "Invoice Processor")
+- **Job**: Specific task description
+- **LLM**: Language model configuration
+- **Tools**: External tools they can use
+- **SOPs**: Standard operating procedures
+
+### Department
+A team of agents working together to accomplish a mission. Departments:
+- **Coordinate multiple agents** in a workflow
+- **Handle dependencies** between agents
+- **Provide execution policies** (retries, timeouts, error handling)
+- **Manage context** and data flow
+
+### ExecutionEngine
+Orchestrates the execution of departments and their workflows with:
+- **Automatic agent coordination**
+- **Tool integration** via MCP (Model Context Protocol)
+- **Error handling and retries**
+- **Execution tracing and monitoring**
+
+### LLM
+Configuration for language models used by agents, supporting:
+- **Multiple model providers** (OpenAI, Anthropic, local models)
+- **Custom parameters** (temperature, max tokens, etc.)
+- **Model-specific configurations**
+
+## 🔥 Real-World Examples
+
+### ETL Invoice Processing Demo
+**Complete end-to-end workflow** that processes PDF invoices using vision models and stores data in PostgreSQL:
+
+```bash
+# Run the ETL demo
+python demos/etl_invoice_processing/etl_invoice_demo.py
+```
+
+This demo showcases:
+- **Vision model integration** for PDF processing
+- **Multi-agent workflow** (Extractor, Validator, Database Engineer)
+- **MCP tool integration** (PostgreSQL, SQL execution)
+- **Data validation and error handling**
+- **Production-ready patterns**
+
+### Smart File Discovery
+Automatically discover and process files with intelligent routing:
+
+```python
+from memra import Agent
+
+# Smart agent that discovers and processes files automatically
+smart_parser = Agent(
+    role="Smart Invoice Parser",
+    job="Discover and process invoice files intelligently",
+    tools=[
+        {"name": "FileDiscovery", "hosted_by": "memra"},
+        {"name": "FileCopy", "hosted_by": "memra"},
+        {"name": "InvoiceExtractionWorkflow", "hosted_by": "memra"}
+    ]
+)
+
+# Three modes of operation:
+# 1. Auto-discovery: Scan invoices/ directory
+# 2. External file: Copy from Downloads to invoices/
+# 3. Specific file: Process exact file path
+```
+
+### Accounts Payable Workflow
+Complete accounts payable processing with validation and database integration:
+
+```python
+# See examples/accounts_payable_smart.py for full implementation
+from memra import Department, Agent
+
+ap_department = Department(
+    name="Accounts Payable",
+    mission="Process and validate vendor invoices",
+    agents=[
+        Agent(role="Invoice Extractor", ...),
+        Agent(role="Data Validator", ...),
+        Agent(role="Database Engineer", ...)
+    ],
+    workflow_order=["Invoice Extractor", "Data Validator", "Database Engineer"]
+)
+```
+
+## 🛠️ Key Features
+
+### 🔌 MCP Integration
+Built-in support for Model Context Protocol (MCP) tools:
+- **Database operations** (PostgreSQL, MySQL, etc.)
+- **File system operations** (discovery, copying, processing)
+- **API integrations** (REST, GraphQL, custom APIs)
+- **Custom tool development** with simple Python functions
+
+### 🎯 Declarative Workflows
+Define workflows in terms of **what** you want to accomplish:
+
+```python
+# Instead of writing procedural code, declare your workflow
+department = Department(
+    name="Invoice Processing",
+    mission="Extract, validate, and store invoice data",
+    agents=[
+        Agent(role="Extractor", job="Extract data from PDFs"),
+        Agent(role="Validator", job="Validate extracted data"),
+        Agent(role="Database Engineer", job="Store data in database")
+    ],
+    workflow_order=["Extractor", "Validator", "Database Engineer"]
+)
+```
+
+### 🔄 Error Handling & Recovery
+Built-in resilience with:
+- **Automatic retries** with configurable policies
+- **Fallback agents** for critical workflows
+- **Validation at each step**
+- **Comprehensive error reporting**
+
+### 📊 Monitoring & Observability
+Track workflow execution with:
+- **Execution traces** showing agent and tool usage
+- **Performance metrics** (timing, costs)
+- **Error logs** with context
+- **Audit trails** for compliance
+
+### 🚀 Production Ready
+Scale from prototype to production:
+- **Async execution** for high throughput
+- **Resource management** and connection pooling
+- **Configuration management** for different environments
+- **Security best practices** for API keys and credentials
+
+## 📚 Documentation
+
+- **[Quick Start Guide](QUICK_START.md)** - Get up and running in 5 minutes
+- **[Detailed Installation Guide](INSTALLATION_GUIDE.md)** - Complete beginner-friendly setup instructions
+- **[System Architecture](memra_system_architecture.md)** - Deep dive into Memra's design
+- **[Text-to-SQL Guide](TEXT_TO_SQL_USAGE_GUIDE.md)** - Building database query workflows
+- **[Examples Directory](examples/)** - Complete working examples
+- **[Demos Directory](demos/)** - Advanced workflow demonstrations
+
+## 🏢 Use Cases
+
+### Financial Services
+- **Invoice processing** and accounts payable automation
+- **Document classification** and routing
+- **Compliance monitoring** and reporting
+- **Risk assessment** and fraud detection
+
+### Healthcare
+- **Medical record processing** and data extraction
+- **Claims processing** and validation
+- **Patient data analysis** and insights
+- **Regulatory compliance** workflows
+
+### Manufacturing
+- **Quality control** and inspection workflows
+- **Supply chain** optimization and monitoring
+- **Equipment maintenance** scheduling
+- **Production planning** and optimization
+
+### Retail & E-commerce
+- **Order processing** and fulfillment
+- **Customer service** automation
+- **Inventory management** and forecasting
+- **Market analysis** and trend detection
+
+## 🤝 Contributing
+
+We welcome contributions! Please see our [contributing guide](CONTRIBUTING.md) for details.
+
+### Development Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/memra-platform/memra-sdk.git
+cd memra-sdk
+
+# Install in development mode
+pip install -e .
+
+# Run tests
+pytest tests/
+```
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+### MIT License Summary
+- ✅ **Commercial use** - Use in proprietary software
+- ✅ **Modification** - Modify and distribute
+- ✅ **Distribution** - Distribute copies
+- ✅ **Private use** - Use privately
+- ❌ **Liability** - No warranty provided
+- ❌ **Warranty** - No warranty provided
+
+## 🆘 Support
+
+- **Issues**: [GitHub Issues](https://github.com/memra-platform/memra-sdk/issues)
+- **Discussions**: [GitHub Discussions](https://github.com/memra-platform/memra-sdk/discussions)
+- **Email**: hello@memra.com
+
+## 🔗 Related Projects
+
+- **[memra-workflows](https://github.com/memra-platform/memra-workflows)** - Production workflow templates
+- **[memra-ops](https://github.com/memra-platform/memra-ops)** - Operations and deployment tools
+
+---
+
+**Built with ❤️ by the memra team** 

{memra-0.2.4.dist-info → memra-0.2.5.dist-info}/RECORD

@@ -1,16 +1,26 @@
-memra/__init__.py,sha256=zVO29fnEDclBI9x9SFVzF9uJYAKhPDTNrMFMWuw6JC8,787
+memra/__init__.py,sha256=InrJf0J3lQruKLuQ4R_JtTll553Die_vDNMCUnTCY2I,1108
+memra/cli.py,sha256=nx_pzbB0ecKzOzg4TDMePV-QFbjlJCyOCoj96zACld4,9289
 memra/discovery.py,sha256=yJIQnrDQu1nyzKykCIuzG_5SW5dIXHCEBLLKRWacIoY,480
 memra/discovery_client.py,sha256=AbnKn6qhyrf7vmOvknEeDzH4tiGHsqPHtDaein_qaW0,1271
-memra/execution.py,sha256=oA66YKds6-8YXQJ7ppCj39C09xuXG1z8GWfF9Tm8Ml0,23861
-memra/models.py,sha256=sXMPRnMB_mUVtJdBFyd0ElCf_uh1yqx7iLssIYNm0vI,3333
+memra/execution.py,sha256=OXpBKxwBIjhACWL_qh8KHNndO8HUgB6gBF81AiQBBm0,34751
+memra/models.py,sha256=3KvjPCaMFGIvI017AIHS23jGnEBZdKHspe1Fp8w0xa0,3418
 memra/tool_registry.py,sha256=PDuWtiX_LX-vhKnx4JeL_ndUwG-oJ6bdhGe6iQeCDBw,15361
-memra/tool_registry_client.py,sha256=uzMQ4COvRams9vuPLcqcdljUpDlAYU_tyFxrRhrA0Lc,4009
-memra-0.2.4.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-memra-ops/app.py,sha256=eyswUTeTvKdPSVy5RHMDW9ijUXdBfYB1qDtwCdkDGDM,26057
+memra/tool_registry_client.py,sha256=dPIj6DMS5wdu99XmVm-NQYHKH_m6nsknCh4C_imTFig,4009
+memra-0.2.5.dist-info/licenses/LICENSE,sha256=8OrnTd8DWwLWmUEj5srSLvT4PREfW1Qo1T5gEUIHPws,1062
+memra-ops/app.py,sha256=S8B82gOAuT9x-NhmVLL9HM03Pde3Fa7QXm6TG1PEbbU,29439
 memra-ops/config.py,sha256=6mBbS_stoEIhJDBqdJOalryAnyWeHbDy81mU1j08ids,969
-memra-ops/server_tool_registry.py,sha256=LYiLUL08M72Poaqt_rWt11BGMFlZKSSWjbW9SnfynEI,8212
+memra-ops/mcp_bridge_server.py,sha256=tDEigRstIEAEu16F1ctCor2ny9CBbEOMY046bHdzFpE,47607
+memra-ops/server_tool_registry.py,sha256=rg5wz8dTfJNqo2QRe69iBKJKeoJemltt_XzZsdxyJa8,8367
 memra-ops/config/config.py,sha256=7dcT9W5b_nWrVAylbdeOaA60_NJlhv2YLyEILTcNKtI,600
+memra-ops/logic/__init__.py,sha256=UFKwzAUU-5pWt-7gcajY1M9PLoJ1wiQ8L0HDTlkRv7E,43
+memra-ops/logic/file_tools.py,sha256=iVe4xE7lNBhhoiL0Hi2zx4oF7koDeVvsOh1uMbn6HEo,1126
+memra-ops/logic/invoice_tools.py,sha256=Jp3PEFfUXRTAAP1ZM4Juei_zzPKy8EFi8H2uP6T9c2A,27787
+memra-ops/logic/invoice_tools_fix.py,sha256=sF4qADqbfWEgOyavslrNlCDEyIkaZo35TtnyHd7PClY,3020
+memra-ops/scripts/check_database.py,sha256=sBPmIJ10WW3jHQfOjeDRJnQahRBwVAi60-98r4HG9rw,987
+memra-ops/scripts/clear_database.py,sha256=yO4JUbMOcSQ1-S57n1oua-SheM360yg-oNiPyj8LW5o,1441
+memra-ops/scripts/monitor_database.py,sha256=OmIgUmtVjtUfSziSEiTy5CheueMMZ5R5HciPpMishE0,2287
 memra-ops/scripts/release.py,sha256=riQ-jz7-vnd1cSfQdU1eUZmVDyuWym1nmZW65lGetiI,4218
+memra-ops/scripts/reset_database.py,sha256=QJagPQIkMOr3s-o-g_Urz0CvSYNm0D2xbwo3JSrKIWY,2255
 memra-ops/scripts/start_memra.py,sha256=VR7WESQXgvPuzZEFMhtmABSR7IzYixsnpgtoPcECLK0,11987
 memra-ops/scripts/stop_memra.py,sha256=yyTu4jxjUbxTrvobQ-UhpNk-eWB8bCFjcBPGW1scIJg,4591
 memra-ops/tests/test_llm_text_to_sql.py,sha256=IDL7FEzlm2Dr9pRCcJQ6SGddF9VBDfHonwztrDpxBGU,4099
@@ -20,7 +30,7 @@ memra-ops/tests/test_schema_aware_sql.py,sha256=b_XPtv7eldR2ARBVlriTHMA1nwqYUcMg
 memra-ops/tests/test_schema_aware_sql_simple.py,sha256=8f8zijkTwvIqVHM3B5oVviRfFS-U6bfC43fk9hcWsoE,2309
 memra-ops/tests/test_text_to_sql_demo.py,sha256=5mmpSwXZ8r8sj3J9iCYkFx0SgwyXPe-7Prie1hL6cis,5092
 memra-ops/tools/mcp_bridge_server.py,sha256=IKUNusZovPdR0_6Bv_XejmAk27lnHrM1uOE8xPVnM8s,35051
-memra-sdk/setup.py,sha256=ZeDcO25CHXm1rHoDZbWI2BE6B7s7LUa9XvFmUu_YEtk,1513
+memra-sdk/setup.py,sha256=j95Pq2ha28B3owPv0J1isq5pgUwa9p02nbBXqxa4Lwo,1513
 memra-sdk/examples/accounts_payable.py,sha256=PfpXKrGOUu6NpkNcHy6cN6TtsXfnsJZhUv-KGlOvDqY,7990
 memra-sdk/examples/accounts_payable_client.py,sha256=tLHHCydEpasLHTHd4YULhSxFy6zs81X5PZHav0dlQ2I,7816
 memra-sdk/examples/accounts_payable_mcp.py,sha256=lOgwDfMVKxifQi70GmeXQnpZiIFrZnNj5_JSZ9qsdBw,7344
@@ -28,7 +38,7 @@ memra-sdk/examples/ask_questions.py,sha256=jek7EVXXZ_vODlMy_hQGQCkN9vYBfaW7SOWsI
 memra-sdk/examples/invoice_processing.py,sha256=STe3ri65WH_Ss84qiRWuGZTpDZke5GoJf8LEqOAc5ys,3980
 memra-sdk/examples/propane_delivery.py,sha256=ryvIxDjM9GJY9T6fFIqJgHOcX2PEMkfF_t_3E5CyZW4,2539
 memra-sdk/examples/simple_text_to_sql.py,sha256=NnpKo9nFpmPQ089zcSx4wwG6_tSHTmGJSS7LPs55NA0,5314
-memra-sdk/memra/__init__.py,sha256=zVO29fnEDclBI9x9SFVzF9uJYAKhPDTNrMFMWuw6JC8,787
+memra-sdk/memra/__init__.py,sha256=CTiSeBBZ40-pNd2-wBIdZduqNLrA5OnWmmwk1y1f894,787
 memra-sdk/memra/discovery.py,sha256=yJIQnrDQu1nyzKykCIuzG_5SW5dIXHCEBLLKRWacIoY,480
 memra-sdk/memra/discovery_client.py,sha256=AbnKn6qhyrf7vmOvknEeDzH4tiGHsqPHtDaein_qaW0,1271
 memra-sdk/memra/execution.py,sha256=P7tAur0SEMtX6uLlfxTfCZBgMLIRj6Wl3dsv2EA9fHc,23443
@@ -51,8 +61,8 @@ memra-workflows/propane_delivery/propane_delivery.py,sha256=ryvIxDjM9GJY9T6fFIqJ
 memra-workflows/text_to_sql/complete_invoice_workflow_with_queries.py,sha256=x4wq3o_ogFnnrI6MQwEhqIiNH-NNwS5SXQUoKd_br7U,7428
 memra-workflows/text_to_sql/complete_text_to_sql_system.py,sha256=Izj4ucXDXTWFY29SWr2YrEf3ZyXH4QCDEljNk4jlpI0,8991
 memra-workflows/text_to_sql/file_discovery_demo.py,sha256=4R_QN0Y6OtHmnX6CvtwDXen122XCDrk-MRBOzxb_x_k,5306
-memra-0.2.4.dist-info/METADATA,sha256=YDEg2IxnhDLka_MA0Ge_cKx_yO2HMFphcGNxnH85t84,4203
-memra-0.2.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-memra-0.2.4.dist-info/entry_points.txt,sha256=LBVjwWoxWJRzNLgeByPn6xUvWFIRnqnemvAZgIoSt08,41
-memra-0.2.4.dist-info/top_level.txt,sha256=IviXF9qSQY_BidRYund9zFaV-q1VMl6CuizwTAggQks,42
-memra-0.2.4.dist-info/RECORD,,
+memra-0.2.5.dist-info/METADATA,sha256=JASskcVQrw_ntJSY3XI5_Ac0Sqi9xC9FpGhsRo3jP08,10736
+memra-0.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+memra-0.2.5.dist-info/entry_points.txt,sha256=8OKRAUYIh1Eg3s6A8dJCIhoPTcyhe0N5_c_GcLXYs48,45
+memra-0.2.5.dist-info/top_level.txt,sha256=IviXF9qSQY_BidRYund9zFaV-q1VMl6CuizwTAggQks,42
+memra-0.2.5.dist-info/RECORD,,

memra-0.2.5.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+memra = scripts.memra:main

memra-0.2.5.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Memra
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

memra-ops/app.py

@@ -12,6 +12,9 @@ import asyncio
 import hashlib
 import hmac
 import aiohttp
+import base64
+import uuid
+from datetime import datetime, timedelta
 from server_tool_registry import ServerToolRegistry
 
 # Add current directory to path for imports
@@ -45,6 +48,16 @@ class ToolExecutionResponse(BaseModel):
 class ToolDiscoveryResponse(BaseModel):
     tools: List[Dict[str, str]]
 
+class FileUploadRequest(BaseModel):
+    filename: str
+    content: str  # base64 encoded
+    content_type: str
+
+class FileUploadResponse(BaseModel):
+    success: bool
+    data: Optional[dict] = None
+    error: Optional[str] = None
+
 # Authentication
 def verify_api_key(api_key: str) -> bool:
     """Verify if the provided API key is valid"""
@@ -75,6 +88,91 @@ async def get_api_key(x_api_key: Optional[str] = Header(None)):
     logger.info(f"Valid API key used: {x_api_key}")
     return x_api_key
 
+# File upload configuration
+UPLOAD_DIR = "/tmp/uploads"
+FILE_EXPIRY_HOURS = 24
+
+# Ensure upload directory exists
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+
+@app.post("/upload", response_model=FileUploadResponse)
+async def upload_file(
+    request: FileUploadRequest,
+    api_key: Optional[str] = Depends(get_api_key)
+):
+    """Upload a file to the server for processing"""
+    try:
+        # Validate file type
+        if not request.content_type.startswith("application/pdf"):
+            raise HTTPException(status_code=400, detail="Only PDF files are supported")
+        
+        # Validate file size (50MB limit)
+        try:
+            file_content = base64.b64decode(request.content)
+            if len(file_content) > 50 * 1024 * 1024:  # 50MB
+                raise HTTPException(status_code=400, detail="File too large (max 50MB)")
+        except Exception as e:
+            raise HTTPException(status_code=400, detail="Invalid base64 content")
+        
+        # Generate unique filename
+        file_id = str(uuid.uuid4())
+        file_extension = os.path.splitext(request.filename)[1]
+        remote_filename = f"{file_id}{file_extension}"
+        remote_path = os.path.join(UPLOAD_DIR, remote_filename)
+        
+        # Save file
+        with open(remote_path, 'wb') as f:
+            f.write(file_content)
+        
+        # Calculate expiry time
+        expires_at = datetime.utcnow() + timedelta(hours=FILE_EXPIRY_HOURS)
+        
+        logger.info(f"File uploaded: {request.filename} -> {remote_filename}")
+        
+        return FileUploadResponse(
+            success=True,
+            data={
+                "remote_path": f"/uploads/{remote_filename}",
+                "file_id": file_id,
+                "expires_at": expires_at.isoformat(),
+                "original_filename": request.filename
+            }
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Upload failed: {str(e)}")
+        return FileUploadResponse(
+            success=False,
+            error=f"Upload failed: {str(e)}"
+        )
+
+async def cleanup_expired_files():
+    """Remove files older than FILE_EXPIRY_HOURS"""
+    while True:
+        try:
+            current_time = datetime.utcnow()
+            for filename in os.listdir(UPLOAD_DIR):
+                file_path = os.path.join(UPLOAD_DIR, filename)
+                file_time = datetime.fromtimestamp(os.path.getctime(file_path))
+                
+                if current_time - file_time > timedelta(hours=FILE_EXPIRY_HOURS):
+                    try:
+                        os.remove(file_path)
+                        logger.info(f"Cleaned up expired file: {filename}")
+                    except Exception as e:
+                        logger.error(f"Failed to clean up {filename}: {e}")
+                        
+        except Exception as e:
+            logger.error(f"File cleanup error: {e}")
+            
+        await asyncio.sleep(3600)  # Run every hour
+
+@app.on_event("startup")
+async def start_cleanup():
+    asyncio.create_task(cleanup_expired_files())
+
 @app.get("/", response_class=HTMLResponse)
 async def landing_page():
     """API documentation landing page"""

memra-ops/logic/__init__.py

@@ -0,0 +1 @@
+# Logic package for Memra API server tools 

memra-ops/logic/file_tools.py

@@ -0,0 +1,43 @@
+"""
+File handling tools for the Memra API server
+"""
+
+import os
+import logging
+from typing import Dict, Any
+
+logger = logging.getLogger(__name__)
+
+class FileReader:
+    """Read files from the filesystem"""
+    
+    def __init__(self):
+        pass
+    
+    def read_file(self, file_path: str) -> Dict[str, Any]:
+        """Read a file and return its contents"""
+        try:
+            if not os.path.exists(file_path):
+                return {
+                    "success": False,
+                    "error": f"File not found: {file_path}"
+                }
+            
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            return {
+                "success": True,
+                "data": {
+                    "file_path": file_path,
+                    "content": content,
+                    "size": len(content)
+                }
+            }
+            
+        except Exception as e:
+            logger.error(f"File reading failed: {str(e)}")
+            return {
+                "success": False,
+                "error": str(e)
+            }