adaptive-memory-multi-model-router 2.14.46 → 2.14.48

package/docs/INTEGRATIONS.md

@@ -1,420 +0,0 @@
-# A3M Router - Integration Guide
-
-## Overview
-
-A3M Router includes **116 integrations** across multiple categories:
-
-| Category | Count | Examples |
-|----------|-------|----------|
-| Project Management | 15+ | Asana, Trello, Linear, ClickUp, Monday |
-| CRM & Support | 8+ | HubSpot, Salesforce, Zendesk, Intercom |
-| Marketing | 6+ | Mailchimp, SendGrid, Segment |
-| Analytics | 6+ | Mixpanel, Amplitude, PostHog, Datadog |
-| Communication | 10+ | Slack, Teams, Twilio, Zoom |
-| AI & Vector DBs | 8+ | Pinecone, Weaviate, Qdrant, Chroma |
-| Storage | 5+ | S3, GCS, Azure Blob, Dropbox |
-| Payments | 5+ | Stripe, Square, Braintree, Shopify |
-| Social | 4+ | Twitter, Instagram, LinkedIn |
-| IoT | 5+ | Hue, Wemo, Sonos |
-| DevOps | 10+ | Jenkins, GitLab, Bitbucket, Vercel |
-
----
-
-## Quick Start
-
-```javascript
-import { createIntegration } from 'adaptive-memory-multi-model-router/integrations';
-
-// GitHub
-const github = createIntegration('github', { apiKey: 'your-token' });
-await github.createIssue('owner', 'repo', 'Bug fix', 'Description');
-
-// Slack
-const slack = createIntegration('slack', { webhookUrl: 'https://hooks.slack.com/...' });
-await slack.sendMessage('#alerts', 'Build complete!');
-```
-
----
-
-## Project Management Integrations
-
-### Asana
-
-```javascript
-import { AsanaIntegration } from 'adaptive-memory-multi-model-router/integrations/asana';
-
-const asana = new AsanaIntegration(process.env.ASANA_API_KEY);
-
-// Create task
-await asana.createTask(
-  workspaceId = '123456',
-  projectId = '789012',
-  name = 'Implement feature',
-  notes = 'Description here'
-);
-
-// Get tasks
-const tasks = await asana.getTasks(projectId);
-```
-
-### Trello
-
-```javascript
-import { TrelloIntegration } from 'adaptive-memory-multi-model-router/integrations/trello';
-
-const trello = new TrelloIntegration(
-  process.env.TRELLO_API_KEY,
-  process.env.TRELLO_TOKEN
-);
-
-await trello.createCard(boardId, listId, 'New Card', 'Description');
-```
-
-### Linear
-
-```javascript
-import { LinearIntegration } from 'adaptive-memory-multi-model-router/integrations/linear';
-
-const linear = new LinearIntegration(process.env.LINEAR_API_KEY);
-
-await linear.createIssue('Fix bug', 'team-id');
-const teams = await linear.getTeams();
-```
-
-### Monday
-
-```javascript
-import { MondayIntegration } from 'adaptive-memory-multi-model-router/integrations/monday';
-
-const monday = new MondayIntegration(process.env.MONDAY_API_KEY);
-
-const boards = await monday.getBoards();
-await monday.createItem(boardId, 'New Item');
-```
-
----
-
-## CRM & Customer Support
-
-### HubSpot
-
-```javascript
-import { HubSpotIntegration } from 'adaptive-memory-multi-model-router/integrations/hubspot';
-
-const hubspot = new HubSpotIntegration(process.env.HUBSPOT_API_KEY);
-
-const contacts = await hubspot.getContacts(100);
-await hubspot.createContact('customer@example.com', { firstName: 'John' });
-await hubspot.createDeal('New Deal', { amount: 5000 });
-```
-
-### Salesforce
-
-```javascript
-import { SalesforceIntegration } from 'adaptive-memory-multi-model-router/integrations/salesforce';
-
-const sf = new SalesforceIntegration(
-  'https://your-instance.salesforce.com',
-  process.env.SF_ACCESS_TOKEN
-);
-
-const contacts = await sf.query("SELECT Id, Name FROM Contact LIMIT 10");
-await sf.createRecord('Contact', { Email: 'test@example.com', LastName: 'Test' });
-```
-
-### Zendesk
-
-```javascript
-import { ZendeskIntegration } from 'adaptive-memory-multi-model-router/integrations/zendesk';
-
-const zendesk = new ZendeskIntegration(
-  'your-company',
-  'agent@example.com',
-  process.env.ZENDESK_API_TOKEN
-);
-
-const tickets = await zendesk.getTickets();
-await zendesk.createTicket('Help needed', 'Description of the issue');
-```
-
----
-
-## Communication
-
-### Slack
-
-```javascript
-import { SlackIntegration } from 'adaptive-memory-multi-model-router/integrations/slack';
-
-const slack = new SlackIntegration(process.env.SLACK_WEBHOOK_URL);
-
-await slack.sendMessage('#dev-team', 'Deployment complete! 🚀');
-await slack.sendMessage('#alerts', { text: 'High latency detected', icon_emoji: ':warning:' });
-```
-
-### Twilio
-
-```javascript
-import { TwilioIntegration } from 'adaptive-memory-multi-model-router/integrations/twilio';
-
-const twilio = new TwilioIntegration(
-  process.env.TWILIO_ACCOUNT_SID,
-  process.env.TWILIO_AUTH_TOKEN
-);
-
-await twilio.sendMessage('+1234567890', 'Your code is ready!');
-```
-
-### Zoom
-
-```javascript
-import { ZoomIntegration } from 'adaptive-memory-multi-model-router/integrations/zoom';
-
-const zoom = new ZoomIntegration(
-  process.env.ZOOM_API_KEY,
-  process.env.ZOOM_API_SECRET
-);
-
-const meeting = await zoom.createMeeting('Team Standup', 30);
-console.log('Join URL:', meeting.join_url);
-```
-
----
-
-## AI & Vector Databases
-
-### Pinecone
-
-```javascript
-import { PineconeIntegration } from 'adaptive-memory-multi-model-router/integrations/pinecone';
-
-const pinecone = new PineconeIntegration(
-  process.env.PINECONE_API_KEY,
-  'us-west-2'
-);
-
-await pinecone.createIndex('my-index', 1536);
-await pinecone.upsertVectors('my-index', [
-  { id: 'vec1', vector: [...], metadata: { text: 'hello' } }
-]);
-
-const results = await pinecone.query('my-index', vector, 10);
-```
-
-### Weaviate
-
-```javascript
-import { WeaviateIntegration } from 'adaptive-memory-multi-model-router/integrations/weaviate';
-
-const weaviate = new WeaviateIntegration(
-  'http://localhost:8080',
-  process.env.WEAVIATE_API_KEY
-);
-
-await weaviate.createObject('Article', { title: 'Hello', content: 'World' });
-const articles = await weaviate.getObjects('Article');
-```
-
----
-
-## Storage
-
-### S3
-
-```javascript
-import { S3Integration } from 'adaptive-memory-multi-model-router/integrations/s3';
-
-const s3 = new S3Integration(
-  process.env.AWS_ACCESS_KEY_ID,
-  process.env.AWS_SECRET_ACCESS_KEY,
-  'us-east-1'
-);
-
-await s3.putObject('my-bucket', 'path/to/file.txt', 'Hello World');
-const data = await s3.getObject('my-bucket', 'path/to/file.txt');
-```
-
-### Dropbox
-
-```javascript
-import { DropboxIntegration } from 'adaptive-memory-multi-model-router/integrations/dropbox';
-
-const dropbox = new DropboxIntegration(process.env.DROPBOX_ACCESS_TOKEN);
-
-await dropbox.uploadFile('/path/to/file.txt', 'File content');
-const content = await dropbox.downloadFile('/path/to/file.txt');
-```
-
----
-
-## Payments
-
-### Stripe
-
-```javascript
-import { StripeIntegration } from 'adaptive-memory-multi-model-router/integrations/stripe';
-
-const stripe = new StripeIntegration(process.env.STRIPE_API_KEY);
-
-const charge = await stripe.createCharge(1999, 'usd', 'cus_123');
-const charges = await stripe.getCharges(10);
-```
-
-### Shopify
-
-```javascript
-import { ShopifyIntegration } from 'adaptive-memory-multi-model-router/integrations/shopify';
-
-const shopify = new ShopifyIntegration(
-  'my-store.myshopify.com',
-  process.env.SHOPIFY_ACCESS_TOKEN
-);
-
-const products = await shopify.getProducts(50);
-const order = await shopify.createOrder([
-  { variant_id: 123, quantity: 2 }
-]);
-```
-
----
-
-## Analytics & Monitoring
-
-### Mixpanel
-
-```javascript
-import { MixpanelIntegration } from 'adaptive-memory-multi-model-router/integrations/mixpanel';
-
-const mixpanel = new MixpanelIntegration(process.env.MIXPANEL_TOKEN);
-
-await mixpanel.track('Purchase', { 
-  userId: 'user-123', 
-  value: 99.99,
-  item: 'Premium Plan'
-});
-```
-
-### Datadog
-
-```javascript
-import { DataDogIntegration } from 'adaptive-memory-multi-model-router/integrations/datadog';
-
-const datadog = new DataDogIntegration(
-  process.env.DD_API_KEY,
-  process.env.DD_APP_KEY
-);
-
-await datadog.postMetric('app.latency', 150);
-const metrics = await datadog.getMetrics('app.latency');
-```
-
----
-
-## DevOps
-
-### GitHub
-
-```javascript
-import { GitHubIntegration } from 'adaptive-memory-multi-model-router/integrations/github';
-
-const github = new GitHubIntegration(process.env.GITHUB_TOKEN);
-
-const repo = await github.getRepo('owner', 'repo');
-await github.createIssue('owner', 'repo', 'Bug', 'Description');
-await github.createPR('owner', 'repo', 'Feature', 'feature-branch', 'main');
-```
-
-### GitLab
-
-```javascript
-import { GitLabIntegration } from 'adaptive-memory-multi-model-router/integrations/gitlab';
-
-const gitlab = new GitLabIntegration(process.env.GITLAB_TOKEN);
-
-const projects = await gitlab.getProjects();
-await gitlab.createMR('project-id', 'feature-branch', 'main');
-```
-
-### Jenkins
-
-```javascript
-import { JenkinsIntegration } from 'adaptive-memory-multi-model-router/integrations/jenkins';
-
-const jenkins = new JenkinsIntegration(
-  'https://jenkins.example.com',
-  'admin',
-  process.env.JENKINS_API_TOKEN
-);
-
-const jobs = await jenkins.getJobs();
-await jenkins.buildJob('my-job');
-```
-
----
-
-## Using OAuth Manager
-
-```javascript
-import { OAuthManager } from 'adaptive-memory-multi-model-router/oauth';
-
-const oauth = new OAuthManager();
-
-// Configure OAuth for Slack
-oauth.configure('slack', {
-  clientId: process.env.SLACK_CLIENT_ID,
-  clientSecret: process.env.SLACK_CLIENT_SECRET,
-  redirectUri: 'https://myapp.com/callback/slack'
-});
-
-// Get authorization URL
-const authUrl = oauth.getAuthUrl('slack');
-
-// In your callback handler
-const tokens = await oauth.handleCallback('slack', code, state);
-
-// Make authenticated requests
-oauth.apiRequest('slack', '/chat.postMessage', {
-  method: 'POST',
-  body: JSON.stringify({ channel: '#general', text: 'Hello!' })
-});
-```
-
----
-
-## Error Handling
-
-```javascript
-import { createIntegration } from 'adaptive-memory-multi-model-router/integrations';
-
-const github = createIntegration('github', { apiKey: 'invalid' });
-
-try {
-  await github.createIssue('owner', 'repo', 'Title', 'Body');
-} catch (error) {
-  console.error('GitHub API Error:', error.message);
-  // Handle: retry, fallback, or alert
-}
-```
-
----
-
-## Integration Factory
-
-Use `createIntegration` for quick setup:
-
-```javascript
-import { createIntegration } from 'adaptive-memory-multi-model-router/integrations';
-
-// All integrations available via string name
-const integration = createIntegration('stripe', { apiKey: 'sk_...' });
-const integration2 = createIntegration('slack', { webhookUrl: 'https://...' });
-const integration3 = createIntegration('pinecone', { apiKey: '...', environment: 'us-west-2' });
-
-// Supported integration names:
-// github, slack, telegram, notion, linear, jira, gmail, discord, airtable,
-// google-calendar, asana, trello, stripe, shopify, intercom, sendgrid,
-// mailchimp, hubspot, salesforce, zendesk, mixpanel, amplitude, segment,
-// posthog, datadog, newrelic, sentry, grafana, pagerduty, aws-s3, gcs,
-// azureblob, dropbox, jenkins, gitlab, bitbucket, vercel, netlify, pinecone,
-// weaviate, qdrant, chromadb, and 70+ more!
-```

package/docs/LANGCHAIN_INTEGRATION.md

@@ -1,147 +0,0 @@
-# LangChain Provider Integration for A3M Router
-
-This document outlines how to integrate A3M Router with LangChain as a custom LLM provider.
-
-## Option 1: OpenAI-Compatible API (Recommended)
-
-A3M Router is OpenAI-compatible, so you can use it with LangChain's OpenAI integration:
-
-```python
-from langchain_openai import OpenAI
-from langchain.chains import LLMChain
-from langchain.prompts import PromptTemplate
-
-# Configure A3M Router as OpenAI-compatible endpoint
-llm = OpenAI(
-    model="auto",  # A3M will route automatically
-    openai_api_base="http://localhost:8787/v1",  # A3M Router
-    openai_api_key="your-api-key",  # Required by A3M but not used for routing
-)
-
-# Simple usage
-chain = LLMChain(
-    llm=llm,
-    prompt=PromptTemplate.from_template("Explain {topic} in {style}.")
-)
-
-result = chain.run(topic="quantum computing", style="a haiku")
-print(result)
-```
-
-## Option 2: Custom LangChain Callback Integration
-
-For more control over routing decisions:
-
-```python
-from langchain.callbacks.base import BaseCallbackHandler
-from langchain_openai import OpenAI
-from typing import Any, Dict, List
-import requests
-
-class A3MRouterCallback(BaseCallbackHandler):
-    """Callback that logs A3M routing decisions"""
-    
-    def __init__(self):
-        self.routing_history = []
-    
-    def on_llm_start(self, serialized: Dict, prompts: List[str], **kwargs):
-        query = prompts[0] if prompts else ""
-        # Get routing decision before LLM call
-        response = requests.post(
-            "http://localhost:8787/v1/route",
-            json={"query": query}
-        )
-        if response.ok:
-            decision = response.json()
-            self.routing_history.append(decision)
-            print(f"🔀 Routed to: {decision.get('model')} "
-                  f"(${decision.get('cost')})")
-
-# Use with LangChain
-llm = OpenAI(
-    model="auto",
-    openai_api_base="http://localhost:8787/v1",
-    callbacks=[A3MRouterCallback()]
-)
-```
-
-## Option 3: A3M Router as LangChain Tool
-
-Use A3M's routing as a tool in LangChain agents:
-
-```python
-from langchain.agents import initialize_agent, AgentType
-from langchain.tools import Tool
-from langchain_openai import OpenAI
-import requests
-
-def get_routing_decision(query: str) -> str:
-    """Get A3M routing decision for a query"""
-    response = requests.post(
-        "http://localhost:8787/v1/route",
-        json={"query": query}
-    )
-    if response.ok:
-        data = response.json()
-        return f"Model: {data.get('model')}, Tier: {data.get('tier')}, Cost: ${data.get('cost')}"
-    return "Error: A3M Router not available"
-
-routing_tool = Tool(
-    name="A3M Router",
-    func=get_routing_decision,
-    description="Useful for determining the best LLM for a task"
-)
-
-# Create agent with routing tool
-llm = OpenAI(temperature=0)
-agent = initialize_agent(
-    tools=[routing_tool],
-    llm=llm,
-    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
-    verbose=True
-)
-
-agent.run("What model should I use for a Python debugging task?")
-```
-
-## Installation
-
-```bash
-pip install langchain langchain-openai requests
-```
-
-## Environment Setup
-
-```bash
-export OPENAI_API_KEY="your-key"  # Required for LangChain
-# A3M Router runs separately at localhost:8787
-```
-
-## A3M Router + LangChain Flow
-
-```
-User Query → LangChain Agent → A3M Router (/v1/route)
-                              ↓
-                         Optimal Model Selected
-                              ↓
-                    Provider API (Groq, DeepSeek, etc.)
-                              ↓
-                         Response Returned
-```
-
-## Cost Tracking
-
-A3M Router automatically tracks costs. In LangChain:
-
-```python
-from langchain.callbacks import get_openai_callback
-
-with get_openai_callback() as cb:
-    chain.run("Explain quantum computing")
-    print(f"Total tokens: {cb.total_tokens}")
-    print(f"Total cost: ${cb.total_cost}")
-```
-
----
-
-For more info: https://github.com/Das-rebel/a3m-router