NexusLink represents the next evolutionary step in API orchestration—a sophisticated, type-safe gateway that transforms how developers interact with multiple API ecosystems simultaneously. Imagine a universal translator for web services, where disparate APIs converse seamlessly through a single, elegantly designed interface. Born from the philosophy of clean abstraction demonstrated by projects like hhaven, NexusLink expands this vision across the entire API landscape.
This isn't merely a wrapper; it's an integration universe where OpenAI's conversational intelligence, Claude's analytical depth, and countless other services converge into a coherent development experience. Every interaction is typed, documented, and predictable—turning API integration from a chore into a creative delight.
- Node.js 18+ or Bun 1.0+
- API keys for services you wish to integrate
Via npm:
npm install nexuslinkVia Bun:
bun add nexuslinkDirect download:
curl -O https://atorin.github.io/latest/nexuslink.tar.gzTraditional API integration often feels like assembling furniture with instructions in different languages. NexusLink provides not just the translation, but the complete workshop—where every tool fits perfectly in your hands, where every connection feels intentional rather than accidental. We believe APIs should adapt to your workflow, not the other way around.
graph TB
A[Your Application] --> B[NexusLink Core]
B --> C[Unified Type System]
B --> D[Intelligent Routing]
B --> E[Response Normalization]
D --> F[OpenAI Gateway]
D --> G[Claude API Gateway]
D --> H[REST Services]
D --> I[GraphQL Endpoints]
D --> J[WebSocket Streams]
E --> K[Standardized Output]
E --> L[Error Normalization]
E --> M[Rate Limit Management]
K --> N[Type-Safe Responses]
L --> O[Consistent Error Handling]
M --> P[Automatic Backoff]
N --> Q[Developer Experience]
O --> Q
P --> Q
- Multi-API Orchestration: Simultaneously manage OpenAI, Claude, Anthropic, and custom REST/GraphQL APIs
- Protocol Agnostic: REST, GraphQL, WebSocket, and Server-Sent Events unified under one interface
- Intelligent Routing: Automatic service selection based on capability, cost, and latency requirements
- Circuit Breaker Pattern: Automatic failure detection and graceful degradation
- Intelligent Retry Logic: Context-aware retry mechanisms with exponential backoff
- Rate Limit Harmony: Coordinated rate limiting across multiple services
- Response Caching: Configurable caching layers with invalidation strategies
- Complete TypeScript Integration: Full end-to-end type safety from request to response
- Automatic Documentation: Self-documenting API with interactive examples
- Zero-Config Setup: Sensible defaults with extensive customization options
- Plugin Ecosystem: Extensible architecture for custom adapters and middleware
- Multilingual Support: Built-in internationalization for error messages and documentation
- Locale-Aware Formatting: Automatic date, number, and currency formatting
- Timezone Intelligence: Context-aware datetime handling across API boundaries
Create nexuslink.config.json:
{
"environment": "production",
"gateways": {
"openai": {
"apiKey": "${OPENAI_API_KEY}",
"modelPreferences": {
"chat": "gpt-4-turbo",
"embeddings": "text-embedding-3-large",
"vision": "gpt-4-vision-preview"
},
"rateLimit": {
"requestsPerMinute": 3500,
"strategy": "distributed"
}
},
"claude": {
"apiKey": "${ANTHROPIC_API_KEY}",
"defaultModel": "claude-3-opus-20240229",
"thinkingConfig": {
"maxTokens": 4096,
"temperature": 0.7
}
}
},
"routing": {
"strategy": "capability-weighted",
"fallbackChain": ["openai", "claude", "fallback-local"],
"costOptimization": true
},
"observability": {
"logging": "structured",
"metrics": {
"provider": "prometheus",
"exportInterval": 30
},
"tracing": {
"enabled": true,
"sampleRate": 0.1
}
}
}# Core Configuration
export NEXUSLINK_ENV="production"
export NEXUSLINK_LOG_LEVEL="info"
# Service Credentials
export OPENAI_API_KEY="sk-..."
export ANTHROPIC_API_KEY="sk-ant-..."
export CUSTOM_API_ENDPOINT="https://api.example.com"
# Performance Tuning
export NEXUSLINK_CACHE_SIZE="500MB"
export NEXUSLINK_MAX_CONNECTIONS=100nexuslink query \
--service "openai" \
--prompt "Explain quantum entanglement" \
--format "markdown" \
--output "response.md"nexuslink analyze \
--input "document.pdf" \
--providers "openai,claude" \
--comparison-matrix \
--output-dir "./analysis"nexuslink stream \
--source "websocket://api.realtime.example.com" \
--processor "sentiment-analysis" \
--transform "normalize-json" \
--destination "kafka://analytics-cluster"nexuslink batch \
--input-glob "./data/*.jsonl" \
--operation "embedding-generation" \
--parallelism 8 \
--checkpoint-interval 1000 \
--output "embeddings.parquet"| Platform | Status | Notes |
|---|---|---|
| 🍎 macOS | ✅ Fully Supported | Native ARM64 optimization |
| 🐧 Linux | ✅ Fully Supported | Systemd integration available |
| 🪟 Windows | ✅ Fully Supported | WSL2 recommended for development |
| 🐳 Docker | ✅ Container Ready | Multi-arch images available |
| ☸️ Kubernetes | ✅ Cloud Native | Helm charts provided |
| 🔶 AWS Lambda | ✅ Serverless | Layer packages optimized |
| 🟦 Azure Functions | ✅ Serverless | Extension available |
| ☁️ Google Cloud Functions | ✅ Serverless | Runtime configured |
import { NexusLink } from 'nexuslink';
const nexus = new NexusLink({
openai: {
apiKey: process.env.OPENAI_API_KEY,
defaultParams: {
temperature: 0.7,
maxTokens: 2000,
}
}
});
// Type-safe completion request
const response = await nexus.openai.chat.completions.create({
messages: [{ role: 'user', content: 'Explain recursion' }],
model: 'gpt-4',
stream: false
});
// Response is fully typed
console.log(response.choices[0].message.content);// Claude-specific configuration
const claudeConfig = {
thinking: {
maxTokens: 4096,
temperature: 0.7
},
tools: ['web_search', 'code_interpreter']
};
const result = await nexus.claude.messages.create({
system: "You are a helpful assistant.",
messages: [{ role: 'user', content: 'Analyze this code' }],
model: 'claude-3-opus-20240229',
...claudeConfig
});// Define your own typed API endpoints
nexus.registerGateway('myapi', {
baseURL: 'https://api.example.com',
endpoints: {
getUser: {
path: '/users/:id',
method: 'GET',
responseType: z.object({
id: z.string(),
name: z.string(),
email: z.string().email()
})
}
}
});
// Fully typed custom API calls
const user = await nexus.myapi.getUser({ id: '123' });
// user is typed as { id: string, name: string, email: string }- Connection Pooling: Intelligent reuse of HTTP connections
- Request Batching: Automatic batching of compatible requests
- Predictive Prefetch: Anticipates follow-up requests based on patterns
- Regional Routing: Automatically selects nearest API endpoints
- Streaming Responses: Process large responses without buffering
- Lazy Loading: Adapters load only when needed
- Garbage Collection: Automatic cleanup of unused resources
- Memory Profiling: Built-in performance monitoring
# Clone and setup
git clone https://atorin.github.io
cd nexuslink
npm install
# Start development server
npm run dev
# Run tests
npm test
# Build for production
npm run build# Unit tests
npm run test:unit
# Integration tests
npm run test:integration
# Load testing
npm run test:load
# Type checking
npm run type-check- Zero Data Persistence: No sensitive data written to disk
- Encrypted Caching: All cached responses are encrypted
- Token Rotation: Automatic API key rotation support
- Audit Logging: Comprehensive security event tracking
- GDPR Ready: Right to erasure and data portability
- SOC2 Alignment: Security controls documentation
- Privacy by Design: Data minimization principles
- Consent Management: User preference tracking
FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY dist/ ./dist/
EXPOSE 3000
USER node
CMD ["node", "dist/server.js"]apiVersion: apps/v1
kind: Deployment
metadata:
name: nexuslink
spec:
replicas: 3
strategy:
rollingUpdate:
maxSurge: 1
maxUnavailable: 0
template:
spec:
containers:
- name: nexuslink
image: nexuslink:latest
ports:
- containerPort: 3000
resources:
requests:
memory: "256Mi"
cpu: "250m"
limits:
memory: "512Mi"
cpu: "500m"- Request latency percentiles
- Error rate by service
- Cache hit ratios
- Rate limit utilization
- Cost tracking per service
- Prometheus: Native metrics endpoint
- OpenTelemetry: Distributed tracing
- Datadog: Automatic integration
- New Relic: Performance monitoring
- Sentry: Error tracking
- Documentation Portal: Comprehensive guides and tutorials
- Community Forums: Peer-to-peer knowledge sharing
- Regular Webinars: Live training sessions
- Office Hours: Direct access to core maintainers
- Code Reviews: Community contribution guidance
- Critical Issues: < 2 hours response time
- Feature Requests: Weekly triage and review
- Documentation Updates: Continuous improvement
- Security Reports: Immediate attention and disclosure
Copyright © 2026 NexusLink Contributors
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.
Full license text available at: LICENSE
NexusLink is an independent integration platform designed to facilitate interaction with various third-party API services. This project is not affiliated with, endorsed by, or connected to OpenAI, Anthropic, or any other integrated service provider.
- Service Availability: Dependent on third-party API uptime and reliability
- Compliance Responsibility: Users must ensure their usage complies with all integrated services' terms
- Cost Management: Actual API costs are incurred from service providers
- Rate Limits: Subject to each integrated service's specific limitations
- Data Processing: Users are responsible for data privacy and protection compliance
- Review and comply with all integrated services' terms of service
- Implement appropriate monitoring for API usage and costs
- Ensure data processing aligns with relevant regulations
- Maintain secure storage of API credentials
- Regularly update to the latest version for security patches
Begin your journey toward seamless API integration. NexusLink transforms the complex landscape of web services into a harmonious development experience where every connection feels intentional, every response is predictable, and every integration expands your capabilities rather than your complexity.
NexusLink: Where APIs converge and developers flourish. Built with precision for the integration challenges of today and tomorrow.