adaptive-memory-multi-model-router 2.15.1 → 2.15.3

package/integrations/browser-use/examples/form-filling.ts

@@ -0,0 +1,179 @@
+/**
+ * Example: Automated Job Application with A3M + browser-use
+ * 
+ * This example demonstrates:
+ * 1. Setting up A3M Router for browser automation
+ * 2. Using stealth mode to avoid detection
+ * 3. Parallel ensemble for reliable form filling
+ * 4. Cost tracking
+ */
+
+import { chromium } from 'playwright';
+import { A3MRouter } from 'adaptive-memory-multi-model-router';
+
+// Resume data to fill into forms
+const RESUME_DATA = {
+  firstName: 'Subhojit',
+  lastName: 'Das',
+  email: 'subho@example.com',
+  phone: '+91-7977110915',
+  location: 'Bengaluru, India',
+  currentTitle: 'Head of Growth Marketing',
+  yearsExperience: '10',
+  linkedin: 'https://www.linkedin.com/in/subhajitd/',
+  website: 'https://subho.dev',
+};
+
+interface JobListing {
+  company: string;
+  title: string;
+  url: string;
+}
+
+async function applyToJob(job: JobListing) {
+  // Initialize A3M for browser automation
+  const router = new A3MRouter({
+    model: 'auto', // Routes to cheapest capable
+    stealth: true, // Enable anti-detection
+    parallelEnsemble: 3, // Run 3 providers for reliability
+    browserOptimized: true,
+    providers: ['openai', 'anthropic', 'google'],
+  });
+
+  console.log(`\nApplying to ${job.title} at ${job.company}...`);
+
+  const browser = await chromium.launch({
+    headless: false, // Set to true for production
+  });
+
+  try {
+    const context = await browser.newContext({
+      // Stealth options
+      userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36',
+    });
+
+    const page = await context.newPage();
+
+    // Navigate to job application page
+    await page.goto(job.url, { waitUntil: 'networkidle' });
+
+    // Use A3M to analyze the form
+    console.log('Analyzing form structure...');
+    const formAnalysis = await router.route({
+      task: `Analyze this job application form. List all fields with:
+        1. Field name/type
+        2. Selector (CSS or XPath)
+        3. Whether it's required
+        4. Expected format`,
+      context: 'form_analysis',
+    });
+
+    console.log(`Found form fields: ${formAnalysis.content.substring(0, 100)}...`);
+
+    // Fill form fields based on analysis
+    const fieldMappings: Record<string, string> = {
+      'first name': RESUME_DATA.firstName,
+      'last name': RESUME_DATA.lastName,
+      'email': RESUME_DATA.email,
+      'phone': RESUME_DATA.phone,
+      'location': RESUME_DATA.location,
+      'current title': RESUME_DATA.currentTitle,
+      'years of experience': RESUME_DATA.yearsExperience,
+      'linkedin': RESUME_DATA.linkedin,
+    };
+
+    // Fill text inputs
+    for (const [fieldName, value] of Object.entries(fieldMappings)) {
+      try {
+        // Find the input field by label
+        const input = await page.locator(`input[aria-label*="${fieldName}" i], input[name*="${fieldName}" i]`).first();
+        
+        if (await input.isVisible()) {
+          await input.fill(value);
+          console.log(`Filled: ${fieldName}`);
+        }
+      } catch (e) {
+        console.log(`Could not fill: ${fieldName}`);
+      }
+    }
+
+    // Upload resume if there's a file input
+    try {
+      const resumeInput = await page.locator('input[type="file"]').first();
+      if (await resumeInput.isVisible()) {
+        await resumeInput.setInputFiles('/path/to/resume.pdf');
+        console.log('Uploaded resume');
+      }
+    } catch (e) {
+      console.log('No file upload field found');
+    }
+
+    // Use A3M to decide if we're ready to submit
+    const pageState = await page.content();
+    const submitDecision = await router.route({
+      task: `Should I submit this form? Review the filled values and check for:
+        1. Required fields are filled
+        2. Values look correct
+        3. No obvious errors
+        
+        Return YES or NO with brief explanation.`,
+      context: 'decision_making',
+    });
+
+    if (submitDecision.content.toLowerCase().includes('yes')) {
+      // Submit the form
+      await page.click('button[type="submit"]');
+      console.log('Form submitted!');
+
+      // Wait for confirmation
+      await page.waitForTimeout(2000);
+      const confirmation = await page.content();
+      
+      if (confirmation.includes('applied') || confirmation.includes('success')) {
+        console.log('✅ Application successful!');
+      }
+    } else {
+      console.log(`❌ Not ready to submit: ${submitDecision.content}`);
+    }
+
+    // Get cost stats
+    const cost = router.getCost();
+    console.log(`Cost for this application: $${cost.total.toFixed(4)}`);
+
+  } finally {
+    await browser.close();
+  }
+}
+
+// Example usage
+async function main() {
+  const jobs: JobListing[] = [
+    {
+      company: 'TechCorp',
+      title: 'Head of Marketing',
+      url: 'https://example.com/jobs/123',
+    },
+    {
+      company: 'StartupXYZ',
+      title: 'VP Growth',
+      url: 'https://example.com/jobs/456',
+    },
+  ];
+
+  console.log('🤖 A3M + browser-use Job Application Bot');
+  console.log('='.repeat(50));
+  console.log(`Applying to ${jobs.length} jobs...\n`);
+
+  for (const job of jobs) {
+    try {
+      await applyToJob(job);
+    } catch (e) {
+      console.error(`Failed to apply to ${job.company}: ${e}`);
+    }
+  }
+
+  console.log('\n' + '='.repeat(50));
+  console.log('All applications complete!');
+}
+
+main().catch(console.error);

package/integrations/browser-use/index.ts

@@ -0,0 +1,145 @@
+/**
+ * A3M Router + browser-use Integration
+ * 
+ * Provides intelligent LLM routing for browser automation tasks.
+ * - Routes to cheapest capable model automatically
+ * - Stealth mode for anti-detection
+ * - Parallel ensemble for reliable extraction
+ */
+
+import { A3MRouter, BrowserConfig } from 'adaptive-memory-multi-model-router';
+
+export interface BrowserUseA3MConfig extends BrowserConfig {
+  /**
+   * Enable stealth mode to minimize bot detection
+   * @default false
+   */
+  stealth?: boolean;
+  
+  /**
+   * Number of providers to run in parallel for ensemble voting
+   * @default 1
+   */
+  parallelEnsemble?: number;
+  
+  /**
+   * Enable browser-specific optimizations
+   * @default true
+   */
+  browserOptimized?: boolean;
+  
+  /**
+   * Preferred models for browser tasks (in order of preference)
+   */
+  preferredBrowserModels?: string[];
+}
+
+/**
+ * Get a browser-use compatible LLM wrapper from A3M Router
+ */
+export function getBrowserUseLLM(config: BrowserUseA3MConfig) {
+  const a3m = new A3MRouter({
+    model: config.model || 'auto',
+    stealth: config.stealth || false,
+    parallelEnsemble: config.parallelEnsemble || 1,
+    providers: config.providers,
+  });
+
+  // Return a wrapper that's compatible with browser-use's LLM interface
+  return {
+    a3m,
+    
+    // Browser-use compatible interface
+    async chat(messages: any[]) {
+      const lastMessage = messages[messages.length - 1];
+      
+      const result = await a3m.route({
+        task: lastMessage.content,
+        context: 'browser_automation',
+      });
+      
+      return {
+        choices: [{
+          message: {
+            role: 'assistant',
+            content: result.content,
+          },
+        }],
+      };
+    },
+    
+    // Get routing stats for monitoring
+    getStats() {
+      return a3m.getStats();
+    },
+    
+    // Get cost for last N requests
+    getCost() {
+      return a3m.getCost();
+    },
+  };
+}
+
+/**
+ * Create an A3M Router optimized for browser automation tasks
+ */
+export function createBrowserAutomationRouter(config: BrowserUseA3MConfig) {
+  const router = new A3MRouter({
+    model: config.model || 'auto',
+    stealth: config.stealth || true,
+    parallelEnsemble: config.parallelEnsemble || 3,
+    browserOptimized: config.browserOptimized !== false,
+    providers: config.providers || ['openai', 'anthropic', 'google', 'groq'],
+  });
+
+  return {
+    router,
+    
+    /**
+     * Route a browser task to the optimal provider
+     */
+    async routeTask(task: string, context?: string) {
+      return router.route({
+        task,
+        context: context || 'browser_automation',
+      });
+    },
+    
+    /**
+     * Extract structured data from a page
+     */
+    async extractData(pageSchema: any, html: string) {
+      return router.route({
+        task: `Extract structured data from this HTML matching the schema: ${JSON.stringify(pageSchema)}`,
+        context: 'data_extraction',
+      });
+    },
+    
+    /**
+     * Fill a form with optimal model selection
+     */
+    async fillForm(formSchema: any, data: any) {
+      return router.route({
+        task: `Fill this form with data: ${JSON.stringify(data)}. Form schema: ${JSON.stringify(formSchema)}`,
+        context: 'form_filling',
+      });
+    },
+    
+    /**
+     * Get stealth routing configuration
+     */
+    getStealthConfig() {
+      return {
+        stealth: config.stealth || true,
+        proxyRotation: true,
+        humanizeTiming: true,
+        randomizeUserAgent: true,
+      };
+    },
+  };
+}
+
+export default {
+  getBrowserUseLLM,
+  createBrowserAutomationRouter,
+};

package/integrations/browser-use/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "a3m-browser-use",
+  "version": "1.0.0",
+  "description": "A3M Router integration for browser-use - cost-optimized browser automation",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "adaptive-memory-multi-model-router": "^2.14.0",
+    "browser-use": "^0.12.0"
+  },
+  "peerDependencies": {
+    "browser-use": "^0.12.0"
+  },
+  "keywords": [
+    "browser-use",
+    "a3m",
+    "llm",
+    "router",
+    "browser-automation",
+    "cost-optimization",
+    "stealth",
+    "anti-detection"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Das-rebel/a3m-router"
+  },
+  "author": "Subhojit Das",
+  "license": "MIT"
+}

package/integrations/browser-use/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "examples"]
+}

package/integrations/mcp-browser/README.md

@@ -0,0 +1,177 @@
+# A3M Router MCP Server for Browser Automation
+
+**Use A3M's intelligent routing as an MCP server for AI agents.**
+
+This integration exposes A3M Router's capabilities via the Model Context Protocol (MCP), enabling AI agents (Claude Desktop, Cursor, Codex, n8n, etc.) to use intelligent LLM routing for browser automation tasks.
+
+## What is MCP?
+
+The [Model Context Protocol](https://modelcontextprotocol.io/) is an open standard for connecting AI assistants to external tools and data sources. MCP servers expose capabilities as "tools" that AI agents can call.
+
+## Installation
+
+```bash
+npm install a3m-mcp-browser
+# or
+npx a3m-mcp-browser
+```
+
+## Setup
+
+### Claude Desktop
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "a3m-browser": {
+      "command": "npx",
+      "args": ["a3m-mcp-browser"]
+    }
+  }
+}
+```
+
+### Cursor
+
+Settings → MCP → Add new server:
+
+```json
+{
+  "name": "a3m-browser",
+  "command": "npx",
+  "args": ["a3m-mcp-browser"]
+}
+```
+
+### n8n
+
+Add MCP Trigger node with server config above.
+
+## Available Tools
+
+### `route_for_browser_task`
+
+Route a browser task to the optimal LLM provider.
+
+```json
+{
+  "task": "Extract all job listings from this page including title, company, and apply URL",
+  "context": "web_scraping"
+}
+```
+
+**Context options:**
+- `web_scraping` - Data extraction from web pages
+- `form_filling` - Filling out web forms
+- `form_analysis` - Analyzing form structure
+- `content_generation` - Generating content for web
+- `decision_making` - Making decisions based on page content
+
+### `extract_form_data`
+
+Extract structured data from a web page.
+
+```json
+{
+  "page_html": "<html>...</html>",
+  "schema": {
+    "name": "string",
+    "email": "string",
+    "jobs": "array"
+  }
+}
+```
+
+### `fill_form_intelligently`
+
+Get optimal values to fill a form field.
+
+```json
+{
+  "field_name": "email",
+  "field_type": "email",
+  "user_profile": {
+    "email": "user@example.com"
+  }
+}
+```
+
+### `get_stealth_routing`
+
+Get routing configuration optimized for stealth.
+
+```json
+{
+  "minimize_detection": true,
+  "provider_rotation": true
+}
+```
+
+## Example Workflow
+
+### Claude Desktop
+
+```
+You: Use A3M to extract all job listings from linkedin.com/jobs/search?q=marketing
+
+Claude: I'll use the A3M router to extract the job data...
+
+[Calls route_for_browser_task with task="Extract all job listings..."]
+
+Claude: I found 25 jobs. Here's the first few:
+
+1. **Head of Marketing** @ TechCorp
+   - URL: https://linkedin.com/jobs/view/123
+   - Location: Bengaluru
+   - Posted: 2 days ago
+
+2. **VP Growth** @ StartupXYZ
+   - URL: https://linkedin.com/jobs/view/456
+   - Location: Mumbai
+   - Posted: 5 days ago
+```
+
+### Cursor
+
+```
+User: Fill out this job application form using my resume data
+
+Cursor: I'll use A3M to intelligently fill the form...
+
+[Calls fill_form_intelligently for each field]
+
+[Calls route_for_browser_task to verify form completion]
+```
+
+## Cost Savings
+
+| Task Type | Without A3M | With A3M | Savings |
+|-----------|-------------|----------|---------|
+| Form filling | $0.03/task | $0.002/task | 93% |
+| Data extraction | $0.01/task | $0.003/task | 70% |
+| Page analysis | $0.02/task | $0.005/task | 75% |
+
+## Features
+
+- **Automatic routing** - Routes to cheapest capable model
+- **Stealth mode** - Minimize bot detection
+- **Parallel ensemble** - Run multiple providers for reliability
+- **Fallback handling** - Automatic retry on failure
+- **Cost tracking** - Monitor spending per task
+
+## Configuration
+
+```json
+{
+  "model": "auto",
+  "stealth": true,
+  "parallelEnsemble": 3,
+  "providers": ["openai", "anthropic", "google", "groq"]
+}
+```
+
+## License
+
+MIT - Same as A3M Router

package/integrations/mcp-browser/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "a3m-mcp-browser",
+  "version": "1.0.0",
+  "description": "A3M Router MCP server for browser automation",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "a3m-mcp-browser": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsc && node dist/index.js"
+  },
+  "dependencies": {
+    "adaptive-memory-multi-model-router": "^2.14.0",
+    "@modelcontextprotocol/sdk": "^0.5.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "a3m",
+    "browser-automation",
+    "llm-routing",
+    "claude",
+    "cursor",
+    "n8n"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Das-rebel/a3m-router"
+  },
+  "author": "Subhojit Das",
+  "license": "MIT"
+}