@aj-archipelago/cortex 1.3.56 → 1.3.58

package/.env.sample

@@ -1 +1,3 @@
-AZURE_OAI_API_KEY=_______________________
+AZURE_OAI_API_KEY=_______________________
+APPTEK_API_KEY=""
+APPTEK_API_ENDPOINT="https://api.apptek.com"

package/README.md

@@ -561,6 +561,12 @@ Each model configuration can include:
 }
 ```
 
+**Rate Limiting**: The `requestsPerSecond` parameter controls the rate limiting for each model endpoint. If not specified, Cortex defaults to **100 requests per second** per endpoint. This rate limiting is implemented using the Bottleneck library with a token bucket algorithm that includes:
+- Minimum time between requests (`minTime`)
+- Maximum concurrent requests (`maxConcurrent`)
+- Token reservoir that refreshes every second
+- Optional Redis clustering support when `storageConnectionString` is configured
+
 ### API Compatibility
 
 Cortex provides OpenAI-compatible REST endpoints that allow you to use various models through a standardized interface. When `enableRestEndpoints` is set to `true`, Cortex exposes the following endpoints:

package/config.js

@@ -389,6 +389,29 @@ var config = convict({
                 "maxTokenLength": 131072,
                 "supportsStreaming": true
             },
+            "google-translate": {
+                "type": "GOOGLE-TRANSLATE",
+                "url": "https://translation.googleapis.com/language/translate/v2",
+                "headers": {
+                    "Content-Type": "application/json"
+                },
+                "requestsPerSecond": 10
+            },
+            "groq-chat": {
+                "type": "GROQ-CHAT",
+                "url": "https://api.groq.com/openai/v1/chat/completions",
+                "headers": {
+                    "Authorization": "Bearer {{GROQ_API_KEY}}",
+                    "Content-Type": "application/json"
+                },
+                "params": {
+                    "model": "meta-llama/llama-4-scout-17b-16e-instruct"
+                },
+                "requestsPerSecond": 10,
+                "maxTokenLength": 65536,
+                "maxReturnTokens": 4096,
+                "supportsStreaming": true
+            },
             "claude-35-sonnet-vertex": {
                 "type": "CLAUDE-3-VERTEX",
                 "url": "{{claudeVertexUrl}}",
@@ -412,6 +435,17 @@ var config = convict({
                 "maxReturnTokens": 4096,
                 "supportsStreaming": true
             },
+            "apptek-translate": {
+                "type": "APPTEK-TRANSLATE",
+                "url": "{{APPTEK_API_ENDPOINT}}",
+                "headers": {
+                    "x-token": "{{APPTEK_API_KEY}}",
+                    "Accept": "application/json",
+                    "Content-Type": "text/plain"
+                },
+                "requestsPerSecond": 10,
+                "maxTokenLength": 128000
+            },
         },
         env: 'CORTEX_MODELS'
     },
@@ -510,6 +544,17 @@ var config = convict({
         format: String,
         default: null,
         env: 'JINA_API_KEY'
+    },
+    apptekApiKey: {
+        format: String,
+        default: null,
+        env: 'APPTEK_API_KEY',
+        sensitive: true
+    },
+    apptekApiEndpoint: {
+        format: String,
+        default: null,
+        env: 'APPTEK_API_ENDPOINT'
     }
 });
 

package/helper-apps/mogrt-handler/.env.example

@@ -0,0 +1,24 @@
+# Server Configuration
+# Port number for the MOGRT handler service
+PORT=7072
+
+# AWS Configuration
+# AWS Region for S3 bucket (default: us-east-1)
+AWS_REGION=us-east-1
+
+# S3 bucket name where MOGRT files and manifests will be stored
+S3_BUCKET_NAME=your-bucket-name
+
+# AWS credentials for S3 access
+AWS_ACCESS_KEY_ID=your-access-key-id
+AWS_SECRET_ACCESS_KEY=your-secret-access-key
+
+# Signed URL Configuration
+# Expiration time for signed URLs in seconds (default: 3600 = 1 hour)
+SIGNED_URL_EXPIRY_SECONDS=3600
+
+# Optional: Node environment (development/production)
+NODE_ENV=development
+
+APPTEK_TOKEN=
+BASE_URL

package/helper-apps/mogrt-handler/README.md

@@ -0,0 +1,166 @@
+# MOGRT Handler Service
+
+A service for managing Motion Graphics Templates (MOGRT) files and their preview GIFs with S3 storage integration.
+
+## Table of Contents
+- [Setup](#setup)
+- [Environment Variables](#environment-variables)
+- [API Documentation](#api-documentation)
+  - [Upload MOGRT Files](#upload-mogrt-files)
+  - [Get Master Manifest](#get-master-manifest)
+  - [Get Individual Manifest](#get-individual-manifest)
+- [File Structure](#file-structure)
+- [Error Handling](#error-handling)
+
+## Setup
+
+1. Install dependencies:
+```bash
+npm install
+```
+
+2. Set up environment variables (see [Environment Variables](#environment-variables) section)
+
+3. Start the server:
+```bash
+npm start
+```
+
+The server will start on port 7072 by default.
+
+## Environment Variables
+
+| Variable | Description | Default | Required |
+|----------|-------------|---------|----------|
+| `PORT` | Server port | 7072 | No |
+| `AWS_REGION` | AWS region for S3 | us-east-1 | No |
+| `S3_BUCKET_NAME` | S3 bucket name for file storage | - | Yes |
+| `AWS_ACCESS_KEY_ID` | AWS access key | - | Yes |
+| `AWS_SECRET_ACCESS_KEY` | AWS secret key | - | Yes |
+| `SIGNED_URL_EXPIRY_SECONDS` | Expiration time for signed URLs | 3600 (1 hour) | No |
+
+## API Documentation
+
+### Upload MOGRT Files
+
+Upload a MOGRT file with its preview GIF.
+
+**Endpoint:** `POST /api/MogrtHandler`
+
+**Content-Type:** `multipart/form-data`
+
+**Required Files:**
+- A `.mogrt` file
+- A `.gif` preview file
+
+**Example Request:**
+```bash
+curl -X POST http://localhost:7072/api/MogrtHandler \
+  -F "mogrt=@/path/to/template.mogrt" \
+  -F "preview=@/path/to/preview.gif"
+```
+
+**Success Response:**
+```json
+{
+  "id": "550e8400-e29b-41d4-a716-446655440000",
+  "mogrtFile": "uploads/550e8400-e29b-41d4-a716-446655440000/template.mogrt",
+  "previewFile": "uploads/550e8400-e29b-41d4-a716-446655440000/preview.gif",
+  "uploadDate": "2025-02-05T14:05:39Z",
+  "mogrtUrl": "https://bucket.s3.amazonaws.com/uploads/550e8400-e29b-41d4-a716-446655440000/template.mogrt?[signed-url-params]",
+  "previewUrl": "https://bucket.s3.amazonaws.com/uploads/550e8400-e29b-41d4-a716-446655440000/preview.gif?[signed-url-params]"
+}
+```
+
+**Error Responses:**
+- `400 Bad Request`: Missing required files or invalid file types
+- `500 Internal Server Error`: Server or S3 error
+
+### Get Master Manifest
+
+Retrieve a list of all uploaded MOGRT files.
+
+**Endpoint:** `GET /api/MogrtHandler`
+
+**Example Request:**
+```bash
+curl http://localhost:7072/api/MogrtHandler
+```
+
+**Success Response:**
+```json
+[
+  {
+    "id": "550e8400-e29b-41d4-a716-446655440000",
+    "mogrtFile": "uploads/550e8400-e29b-41d4-a716-446655440000/template.mogrt",
+    "previewFile": "uploads/550e8400-e29b-41d4-a716-446655440000/preview.gif",
+    "uploadDate": "2025-02-05T14:05:39Z",
+    "mogrtUrl": "https://bucket.s3.amazonaws.com/uploads/550e8400-e29b-41d4-a716-446655440000/template.mogrt?[signed-url-params]",
+    "previewUrl": "https://bucket.s3.amazonaws.com/uploads/550e8400-e29b-41d4-a716-446655440000/preview.gif?[signed-url-params]"
+  }
+]
+```
+
+**Error Response:**
+- `500 Internal Server Error`: Server or S3 error
+
+### Get Individual Manifest
+
+Retrieve information about a specific MOGRT upload.
+
+**Endpoint:** `GET /api/MogrtHandler?manifestId=<uuid>`
+
+**Parameters:**
+- `manifestId` (required): UUID of the upload
+
+**Example Request:**
+```bash
+curl http://localhost:7072/api/MogrtHandler?manifestId=550e8400-e29b-41d4-a716-446655440000
+```
+
+**Success Response:**
+```json
+{
+  "id": "550e8400-e29b-41d4-a716-446655440000",
+  "mogrtFile": "uploads/550e8400-e29b-41d4-a716-446655440000/template.mogrt",
+  "previewFile": "uploads/550e8400-e29b-41d4-a716-446655440000/preview.gif",
+  "uploadDate": "2025-02-05T14:05:39Z",
+  "mogrtUrl": "https://bucket.s3.amazonaws.com/uploads/550e8400-e29b-41d4-a716-446655440000/template.mogrt?[signed-url-params]",
+  "previewUrl": "https://bucket.s3.amazonaws.com/uploads/550e8400-e29b-41d4-a716-446655440000/preview.gif?[signed-url-params]"
+}
+```
+
+**Error Responses:**
+- `404 Not Found`: Manifest not found
+- `500 Internal Server Error`: Server or S3 error
+
+## File Structure
+
+Files are organized in S3 with the following structure:
+
+```
+bucket/
+├── master-manifest.json
+└── uploads/
+    └── <uuid>/
+        ├── template.mogrt
+        ├── preview.gif
+        └── manifest.json
+```
+
+## Error Handling
+
+All endpoints return errors in the following format:
+
+```json
+{
+  "error": "Error message description"
+}
+```
+
+Common error scenarios:
+1. Missing required files in upload
+2. Invalid file types (only .mogrt and .gif allowed)
+3. S3 access or permission issues
+4. Missing or invalid manifest ID
+5. Server configuration errors (missing environment variables)

package/helper-apps/mogrt-handler/glossaryHandler.js

@@ -0,0 +1,218 @@
+import fetch from 'node-fetch';
+import dotenv from 'dotenv';
+import { saveGlossaryId, getGlossaryVersions, getGlossaryVersion } from './s3Handler.js';
+
+dotenv.config();
+
+const APPTEK_BASE_URL = process.env.APPTEK_API_URL || 'https://api.apptek.com/api/v2/glossary';
+const APPTEK_TOKEN = process.env.APPTEK_TOKEN;
+
+export default async function GlossaryHandler(context, req) {
+    const { method, url, body, query, headers } = req;
+    // Use token from header if present, else from env
+    const token = APPTEK_TOKEN;
+    if (!token) {
+        context.res = { status: 401, body: { error: 'Missing x-token or APPTEK_TOKEN' } };
+        return;
+    }
+    try {
+        // List glossaries
+        if (method === 'GET' && url.includes('/list')) {
+            const resp = await fetch(`${APPTEK_BASE_URL}/list`, {
+                method: 'GET',
+                headers: { 'accept': 'application/json', 'x-token': token }
+            });
+            const data = await resp.json();
+            context.res = { status: resp.status, body: data };
+            return;
+        }
+        // Create glossary
+        if (method === 'POST' && url.match(/\/api\/glossary\/[a-z]{2}-[a-z]{2}/)) {
+            const langPair = url.match(/\/api\/glossary\/([a-z]{2}-[a-z]{2})/)[1];
+            body.name = ""
+
+            for (const entry of body.entries) {
+                entry.target_alternatives = [];
+            }
+            const resp = await fetch(`${APPTEK_BASE_URL}/${langPair}`, {
+                method: 'POST',
+                headers: { 'accept': 'application/json', 'x-token': token, 'content-type': 'application/json' },
+                body: JSON.stringify(body)
+            });
+            console.log(resp)
+            const data = await resp.json();
+            
+            // If successful, save the glossary ID to S3 with versioning
+            if (resp.status === 200 && data.glossary_id) {
+                try {
+                    const versionInfo = await saveGlossaryId(data.glossary_id, langPair, name);
+                    // Add version info to the response
+                    data.version = {
+                        versionId: versionInfo.versionId,
+                        key: versionInfo.key
+                    };
+                } catch (s3Error) {
+                    console.error('Error saving glossary ID to S3:', s3Error);
+                    // Don't fail the request if S3 storage fails
+                    data.versioningError = 'Failed to save glossary version to S3';
+                }
+            }
+            
+            context.res = { status: resp.status, body: data };
+            return;
+        }
+        // Delete glossary
+        if (method === 'DELETE' && url.match(/\/api\/glossary\/.+/)) {
+            const glossaryId = url.split('/').pop();
+            console.log(`🗑️ Attempting to delete glossary with ID: ${glossaryId}`);
+            
+            try {
+                const resp = await fetch(`${APPTEK_BASE_URL}/${glossaryId}`, {
+                    method: 'DELETE',
+                    headers: { 'accept': 'application/json', 'x-token': token }
+                });
+                
+                console.log(`📤 Delete request sent, response status: ${resp.status}`);
+                
+                const data = await resp.json().catch(() => {
+                    console.log(`⚠️ No JSON in delete response, using empty object`);
+                    return {};
+                });
+                
+                if (resp.status === 200) {
+                    console.log(`✅ Successfully deleted glossary ${glossaryId}`);
+                } else {
+                    console.error(`❌ Failed to delete glossary ${glossaryId}, status: ${resp.status}`, data);
+                }
+                
+                context.res = { status: resp.status, body: data };
+            } catch (error) {
+                console.error(`❌ Error during glossary deletion: ${error.message}`);
+                context.res = { status: 500, body: { error: `Error deleting glossary: ${error.message}` } };
+            }
+            return;
+        }
+        // Edit glossary: delete then create
+        if (method === 'POST' && url.includes('/edit/')) {
+            const glossaryId = url.split('/edit/').pop();
+            // 1. Delete
+            console.log(`🗑️ Deleting glossary with ID: ${glossaryId} as part of edit operation`);
+            try {
+                const deleteResp = await fetch(`${APPTEK_BASE_URL}/${glossaryId}`, {
+                    method: 'DELETE',
+                    headers: { 'accept': 'application/json', 'x-token': token }
+                });
+                
+                console.log(`📤 Delete request (for edit) sent, response status: ${deleteResp.status}`);
+                
+                if (deleteResp.status === 200) {
+                    console.log(`✅ Successfully deleted glossary ${glossaryId} for edit operation`);
+                } else {
+                    console.warn(`⚠️ Non-200 status when deleting glossary for edit: ${deleteResp.status}`);
+                }
+            } catch (deleteError) {
+                console.error(`❌ Error during glossary deletion for edit: ${deleteError.message}`);
+                // Continue with create even if delete fails
+            }
+            // 2. Create (reuse create logic)
+            const { source_lang_code, target_lang_code, entries } = body;
+            body.name = ""
+            const langPair = `${source_lang_code}-${target_lang_code}`;
+            const resp = await fetch(`${APPTEK_BASE_URL}/${langPair}`, {
+                method: 'POST',
+                headers: { 'accept': 'application/json', 'x-token': token, 'content-type': 'application/json' },
+                body: JSON.stringify(body)
+            });
+            const data = await resp.json();
+            
+            // If successful, save the glossary ID to S3 with versioning
+            if (resp.status === 200 && data.glossary_id) {
+                try {
+                    const versionInfo = await saveGlossaryId(data.glossary_id, langPair);
+                    // Add version info to the response
+                    data.version = {
+                        versionId: versionInfo.versionId,
+                        key: versionInfo.key
+                    };
+                } catch (s3Error) {
+                    console.error('Error saving glossary ID to S3:', s3Error);
+                    // Don't fail the request if S3 storage fails
+                    data.versioningError = 'Failed to save glossary version to S3';
+                }
+            }
+            
+            context.res = { status: resp.status, body: data };
+            return;
+        }
+        // Get versions of a glossary
+        if (method === 'GET' && url.match(/\/api\/glossary\/([a-z]{2}-[a-z]{2})\/versions\/(.*)/)) {
+            const matches = url.match(/\/api\/glossary\/([a-z]{2}-[a-z]{2})\/versions\/(.*)/); 
+            const langPair = matches[1];
+            const glossaryId = matches[2];
+            const name = query.name || '';
+            
+            try {
+                const versions = await getGlossaryVersions(glossaryId, langPair, name);
+                context.res = { status: 200, body: { versions } };
+            } catch (error) {
+                context.res = { status: 500, body: { error: error.message } };
+            }
+            return;
+        }
+        
+        // Get a specific version of a glossary
+        if (method === 'GET' && url.match(/\/api\/glossary\/([a-z]{2}-[a-z]{2})\/version\/(.*)\/(.*)/))
+        {
+            const matches = url.match(/\/api\/glossary\/([a-z]{2}-[a-z]{2})\/version\/(.*)\/(.*)/);
+            const langPair = matches[1];
+            const glossaryId = matches[2];
+            const versionId = matches[3];
+            const name = query.name || '';
+            
+            try {
+                const version = await getGlossaryVersion(glossaryId, langPair, versionId, name);
+                context.res = { status: 200, body: version };
+            } catch (error) {
+                context.res = { status: 500, body: { error: error.message } };
+            }
+            return;
+        }
+        
+        // Get glossary by ID
+        if (method === 'GET' && url.match(/\/api\/glossary\/([^/]+)$/))
+        {
+            const glossaryId = url.match(/\/api\/glossary\/([^/]+)$/)[1];
+            console.log(`📖 Fetching glossary with ID: ${glossaryId}`);
+            
+            try {
+                const resp = await fetch(`${APPTEK_BASE_URL}/${glossaryId}`, {
+                    method: 'GET',
+                    headers: {'x-token': token }
+                });
+                
+                console.log(`📤 Get glossary request sent, response status: ${resp.status}`);
+                
+                const data = await resp.json().catch(() => {
+                    console.log(`⚠️ No JSON in response, using empty object`);
+                    return {};
+                });
+                
+                if (resp.status === 200) {
+                    console.log(`✅ Successfully retrieved glossary ${glossaryId}`);
+                } else {
+                    console.error(`❌ Failed to retrieve glossary ${glossaryId}, status: ${resp.status}`, data);
+                }
+                
+                context.res = { status: resp.status, body: data };
+            } catch (error) {
+                console.error(`❌ Error retrieving glossary: ${error.message}`);
+                context.res = { status: 500, body: { error: `Error retrieving glossary: ${error.message}` } };
+            }
+            return;
+        }
+        
+        context.res = { status: 404, body: { error: 'Not found' } };
+    } catch (error) {
+        context.res = { status: 500, body: { error: error.message } };
+    }
+}