# Configuration Guide
Source: https://docs.mypraxos.com/deployment/configuration
Configure Praxos for your environment
## Overview
Praxos is configured primarily through environment variables. This guide covers all available configuration options.
## Core Configuration
### Environment
```bash theme={null}
ENVIRONMENT=production # development, staging, production
LOG_LEVEL=info # debug, info, warning, error, critical
```
### Server
```bash theme={null}
HOST=0.0.0.0 # Listen address
PORT=8000 # Server port
RELOAD=false # Auto-reload on code changes (dev only)
WORKERS=4 # Number of worker processes
```
## Database Configuration
### MongoDB
```bash theme={null}
MONGODB_URI=mongodb://username:password@host:27017/
DATABASE_NAME=hetairos
MONGODB_MAX_POOL_SIZE=100
MONGODB_MIN_POOL_SIZE=10
MONGODB_SERVER_SELECTION_TIMEOUT_MS=5000
```
### Azure Cosmos DB
```bash theme={null}
AZURE_COSMOS_ENDPOINT=https://your-account.documents.azure.com:443/
AZURE_COSMOS_KEY=your-cosmos-key
DATABASE_NAME=hetairos
```
## Message Queue
### Azure Service Bus
```bash theme={null}
AZURE_SERVICE_BUS_CONNECTION_STRING=Endpoint=sb://...
AZURE_SERVICE_BUS_QUEUE_NAME=agent_tasks
AZURE_SERVICE_BUS_MAX_CONCURRENT_MESSAGES=10
```
### Redis (Alternative)
```bash theme={null}
REDIS_URL=redis://localhost:6379
REDIS_MAX_CONNECTIONS=50
REDIS_SOCKET_KEEPALIVE=true
```
## LLM Configuration
### Portkey (Gateway)
```bash theme={null}
PORTKEY_API_KEY=your-portkey-key
PORTKEY_VIRTUAL_KEY=your-virtual-key
```
### OpenAI
```bash theme={null}
OPENAI_API_KEY=your-openai-key
OPENAI_MODEL=gpt-4-turbo-preview
OPENAI_MAX_TOKENS=4096
OPENAI_TEMPERATURE=0.7
```
### Google Gemini
```bash theme={null}
GOOGLE_API_KEY=your-google-key
GOOGLE_MODEL=gemini-pro
GOOGLE_MAX_TOKENS=8192
```
## Secrets Management
### Azure Key Vault
```bash theme={null}
AZURE_KEY_VAULT_URL=https://your-keyvault.vault.azure.net/
AZURE_TENANT_ID=your-tenant-id
AZURE_CLIENT_ID=your-client-id
AZURE_CLIENT_SECRET=your-client-secret
```
When using Key Vault, individual secrets can be:
* Stored in Key Vault and auto-loaded at runtime
* Or specified directly as env vars
## Integration Configuration
### Telegram
```bash theme={null}
TELEGRAM_BOT_TOKEN=123456:ABC-DEF...
TELEGRAM_WEBHOOK_URL=https://your-domain.com/telegram/webhook
TELEGRAM_MAX_MESSAGE_LENGTH=4096
TELEGRAM_PARSE_MODE=Markdown # or HTML
```
### Discord
```bash theme={null}
DISCORD_BOT_TOKEN=your-discord-token
DISCORD_APPLICATION_ID=your-app-id
DISCORD_COMMAND_PREFIX=!
DISCORD_MAX_MESSAGE_LENGTH=2000
```
### Slack
```bash theme={null}
SLACK_BOT_TOKEN=xoxb-...
SLACK_SIGNING_SECRET=your-signing-secret
SLACK_APP_TOKEN=xapp-... # For Socket Mode
SLACK_SOCKET_MODE=false
```
### WhatsApp
```bash theme={null}
WHATSAPP_PHONE_NUMBER_ID=your-phone-number-id
WHATSAPP_ACCESS_TOKEN=your-access-token
WHATSAPP_WEBHOOK_VERIFY_TOKEN=your-verify-token
```
### Google Services
```bash theme={null}
GOOGLE_CLIENT_ID=your-client-id
GOOGLE_CLIENT_SECRET=your-client-secret
GOOGLE_REDIRECT_URI=https://your-domain.com/auth/google/callback
GOOGLE_API_KEY=your-api-key # For services without OAuth
```
### Microsoft 365
```bash theme={null}
MICROSOFT_CLIENT_ID=your-app-id
MICROSOFT_CLIENT_SECRET=your-secret
MICROSOFT_TENANT_ID=your-tenant-id
MICROSOFT_REDIRECT_URI=https://your-domain.com/auth/microsoft/callback
```
### Notion
```bash theme={null}
NOTION_CLIENT_ID=your-client-id
NOTION_CLIENT_SECRET=your-client-secret
NOTION_REDIRECT_URI=https://your-domain.com/auth/notion/callback
```
### Trello
```bash theme={null}
TRELLO_API_KEY=your-api-key
TRELLO_TOKEN=your-token
```
### Dropbox
```bash theme={null}
DROPBOX_APP_KEY=your-app-key
DROPBOX_APP_SECRET=your-app-secret
DROPBOX_REDIRECT_URI=https://your-domain.com/auth/dropbox/callback
```
## Feature Flags
```bash theme={null}
# Enable/disable features
ENABLE_BROWSER_TOOL=true
ENABLE_SCHEDULED_TASKS=true
ENABLE_FILE_PROCESSING=true
ENABLE_VOICE_MESSAGES=true
ENABLE_VISION_FEATURES=false # Future
# Feature limits
MAX_FILE_SIZE_MB=25
MAX_MESSAGE_HISTORY=100
MAX_CONCURRENT_TASKS_PER_USER=5
```
## Performance Tuning
### Worker Configuration
```bash theme={null}
MAX_WORKERS=4 # Number of worker processes
WORKER_TIMEOUT_SECONDS=300 # Worker timeout
MAX_TASKS_PER_WORKER=100 # Tasks before worker restart
WORKER_PREFETCH_COUNT=5 # Messages to prefetch
```
### Caching
```bash theme={null}
ENABLE_CACHE=true
CACHE_TTL_SECONDS=300 # 5 minutes
CACHE_MAX_SIZE_MB=100
USER_CONTEXT_CACHE_TTL=300
INTEGRATION_CACHE_TTL=3600
```
### Rate Limiting
```bash theme={null}
RATE_LIMIT_ENABLED=true
RATE_LIMIT_PER_USER=100 # Requests per minute
RATE_LIMIT_BURST=20 # Burst allowance
```
### Timeouts
```bash theme={null}
HTTP_CLIENT_TIMEOUT=30 # HTTP request timeout (seconds)
DATABASE_QUERY_TIMEOUT=10 # Database query timeout
TOOL_EXECUTION_TIMEOUT=120 # Tool execution timeout
BROWSER_TIMEOUT=60 # Browser automation timeout
```
## Logging Configuration
### Log Levels
```bash theme={null}
LOG_LEVEL=info # Global log level
LOG_FORMAT=json # json or text
# Per-module log levels
LOG_LEVEL_LANGCHAIN=warning
LOG_LEVEL_HTTPX=warning
LOG_LEVEL_AZURE=warning
LOG_LEVEL_PLAYWRIGHT=error
```
### Log Destinations
```bash theme={null}
LOG_TO_FILE=true
LOG_FILE_PATH=/var/log/hetairos/app.log
LOG_FILE_MAX_BYTES=10485760 # 10MB
LOG_FILE_BACKUP_COUNT=5
LOG_TO_CONSOLE=true
LOG_TO_AZURE_INSIGHTS=true # If using Azure
```
## Security Configuration
### CORS
```bash theme={null}
CORS_ENABLED=true
CORS_ORIGINS=["https://yourdomain.com"]
CORS_ALLOW_CREDENTIALS=true
```
### API Security
```bash theme={null}
API_KEY_REQUIRED=true # Require API key for endpoints
API_KEYS=["key1", "key2"] # Allowed API keys
ENABLE_RATE_LIMITING=true
```
### Data Protection
```bash theme={null}
ENCRYPT_USER_DATA=true
ENCRYPTION_KEY=your-encryption-key
MASK_SENSITIVE_LOGS=true
```
## Monitoring
### Metrics
```bash theme={null}
ENABLE_METRICS=true
METRICS_PORT=9090
PROMETHEUS_MULTIPROC_DIR=/tmp/prometheus
```
### Health Checks
```bash theme={null}
HEALTH_CHECK_ENABLED=true
HEALTH_CHECK_PATH=/health
READINESS_CHECK_PATH=/ready
```
### Azure Application Insights
```bash theme={null}
APPINSIGHTS_INSTRUMENTATION_KEY=your-key
APPINSIGHTS_CONNECTION_STRING=InstrumentationKey=...
ENABLE_TELEMETRY=true
```
## Scheduled Tasks
```bash theme={null}
ENABLE_SCHEDULED_TASKS=true
SCHEDULED_TASK_CHECK_INTERVAL=60 # seconds
MAX_SCHEDULED_TASKS_PER_USER=50
```
## Browser Configuration
```bash theme={null}
# Playwright settings
PLAYWRIGHT_BROWSER=chromium # chromium, firefox, webkit
PLAYWRIGHT_HEADLESS=true
PLAYWRIGHT_TIMEOUT=60000 # milliseconds
BROWSER_MAX_STEPS=10 # Max AI browser actions
```
## Webhook Configuration
```bash theme={null}
WEBHOOK_BASE_URL=https://your-domain.com
WEBHOOK_SECRET=your-webhook-secret
WEBHOOK_TIMEOUT=5 # seconds
```
## Time Zone
```bash theme={null}
TIMEZONE=UTC # Default timezone
TIMEZONE_DATABASE_PATH=/usr/share/zoneinfo
```
## Example Configurations
### Development
```bash theme={null}
ENVIRONMENT=development
LOG_LEVEL=debug
RELOAD=true
MONGODB_URI=mongodb://localhost:27017/
DATABASE_NAME=hetairos_dev
REDIS_URL=redis://localhost:6379
ENABLE_CACHE=false
```
### Staging
```bash theme={null}
ENVIRONMENT=staging
LOG_LEVEL=info
RELOAD=false
MONGODB_URI=mongodb+srv://...
DATABASE_NAME=hetairos_staging
AZURE_SERVICE_BUS_CONNECTION_STRING=...
ENABLE_CACHE=true
ENABLE_METRICS=true
```
### Production
```bash theme={null}
ENVIRONMENT=production
LOG_LEVEL=info
RELOAD=false
WORKERS=8
# Use Azure Cosmos DB
AZURE_COSMOS_ENDPOINT=https://...
DATABASE_NAME=hetairos
# Use Azure Service Bus
AZURE_SERVICE_BUS_CONNECTION_STRING=...
# Use Azure Key Vault
AZURE_KEY_VAULT_URL=https://...
# Monitoring
ENABLE_METRICS=true
APPINSIGHTS_CONNECTION_STRING=...
# Security
API_KEY_REQUIRED=true
ENCRYPT_USER_DATA=true
MASK_SENSITIVE_LOGS=true
# Performance
ENABLE_CACHE=true
CACHE_TTL_SECONDS=600
MAX_WORKERS=8
WORKER_PREFETCH_COUNT=10
```
## Configuration File (.env)
Create a `.env` file:
```bash theme={null}
# Core
ENVIRONMENT=production
LOG_LEVEL=info
# Database
MONGODB_URI=your-mongodb-uri
DATABASE_NAME=hetairos
# Queue
AZURE_SERVICE_BUS_CONNECTION_STRING=your-connection-string
# Secrets
AZURE_KEY_VAULT_URL=your-keyvault-url
# LLM
PORTKEY_API_KEY=your-portkey-key
OPENAI_API_KEY=your-openai-key
# Integrations (configure as needed)
TELEGRAM_BOT_TOKEN=your-telegram-token
DISCORD_BOT_TOKEN=your-discord-token
# ... more integrations
```
## Loading Configuration
### From Environment
```python theme={null}
import os
from dotenv import load_dotenv
load_dotenv()
environment = os.getenv("ENVIRONMENT", "development")
log_level = os.getenv("LOG_LEVEL", "info")
```
### From Azure Key Vault
```python theme={null}
from azure.identity import DefaultAzureCredential
from azure.keyvault.secrets import SecretClient
credential = DefaultAzureCredential()
client = SecretClient(
vault_url=os.getenv("AZURE_KEY_VAULT_URL"),
credential=credential
)
telegram_token = client.get_secret("telegram-bot-token").value
```
## Validation
Praxos validates configuration on startup:
```python theme={null}
# Example validation
required_vars = [
"MONGODB_URI",
"PORTKEY_API_KEY",
"OPENAI_API_KEY"
]
for var in required_vars:
if not os.getenv(var):
raise ValueError(f"Required environment variable {var} not set")
```
## Troubleshooting
### Configuration Not Loading
* Check `.env` file exists
* Verify file is in correct directory
* Check for typos in variable names
* Ensure proper file permissions
### Secrets Not Found
* Verify Azure Key Vault URL is correct
* Check authentication credentials
* Ensure secrets exist in Key Vault
* Verify secret names match
### Connection Errors
* Validate connection strings
* Check network connectivity
* Verify firewall rules
* Test credentials
## Best Practices
1. **Never commit secrets** - Use `.gitignore` for `.env` files
2. **Use Key Vault in production** - Don't store secrets in env vars
3. **Separate configs per environment** - dev, staging, production
4. **Validate on startup** - Fail fast if config is incorrect
5. **Document all variables** - Maintain configuration documentation
6. **Use defaults wisely** - Provide sensible defaults
7. **Environment-specific overrides** - Allow per-environment customization
## Next Steps
Deploy to Kubernetes
Review requirements
Local development setup
# Kubernetes Deployment
Source: https://docs.mypraxos.com/deployment/kubernetes
Deploy Praxos to Kubernetes
## Overview
This guide covers deploying Praxos to a Kubernetes cluster using Azure Kubernetes Service (AKS) as an example. The concepts apply to other Kubernetes platforms with minor adjustments.
## Prerequisites
* Kubernetes cluster (1.24+)
* kubectl configured
* Docker image built and pushed to registry
* Required secrets and config maps
* Load balancer or ingress controller
## Architecture
```mermaid theme={null}
graph TB
A[Internet] --> B[Load Balancer]
B --> C[Ingress]
C --> D[API Service]
D --> E[API Pods]
E --> F[Service Bus Queue]
F --> G[Worker Pods]
G --> H[Cosmos DB]
E --> H
G --> I[Key Vault]
E --> I
```
## Namespace
Create a namespace for Praxos:
```yaml theme={null}
apiVersion: v1
kind: Namespace
metadata:
name: hetairos
labels:
name: hetairos
```
Apply:
```bash theme={null}
kubectl apply -f namespace.yaml
```
## Secrets
### Create Secret from Azure Key Vault
If using Azure Key Vault:
```yaml theme={null}
apiVersion: v1
kind: Secret
metadata:
name: hetairos-secrets
namespace: hetairos
type: Opaque
stringData:
AZURE_KEY_VAULT_URL: "https://your-keyvault.vault.azure.net/"
AZURE_TENANT_ID: "your-tenant-id"
AZURE_CLIENT_ID: "your-client-id"
AZURE_CLIENT_SECRET: "your-client-secret"
```
### Or create secrets directly
```yaml theme={null}
apiVersion: v1
kind: Secret
metadata:
name: hetairos-secrets
namespace: hetairos
type: Opaque
stringData:
MONGODB_URI: "mongodb://..."
PORTKEY_API_KEY: "your-portkey-key"
OPENAI_API_KEY: "your-openai-key"
GOOGLE_API_KEY: "your-google-key"
TELEGRAM_BOT_TOKEN: "your-telegram-token"
DISCORD_BOT_TOKEN: "your-discord-token"
# Add other secrets as needed
```
Apply:
```bash theme={null}
kubectl apply -f secrets.yaml
```
## ConfigMap
Create a ConfigMap for non-sensitive configuration:
```yaml theme={null}
apiVersion: v1
kind: ConfigMap
metadata:
name: hetairos-config
namespace: hetairos
data:
ENVIRONMENT: "production"
LOG_LEVEL: "info"
DATABASE_NAME: "hetairos"
QUEUE_NAME: "agent_tasks"
MAX_WORKERS: "4"
TIMEZONE: "UTC"
```
Apply:
```bash theme={null}
kubectl apply -f configmap.yaml
```
## API Deployment
```yaml theme={null}
apiVersion: apps/v1
kind: Deployment
metadata:
name: hetairos-api
namespace: hetairos
labels:
app: hetairos
component: api
spec:
replicas: 2
selector:
matchLabels:
app: hetairos
component: api
template:
metadata:
labels:
app: hetairos
component: api
spec:
containers:
- name: api
image: your-registry.azurecr.io/hetairos:latest
imagePullPolicy: Always
command: ["python", "src/main.py"]
ports:
- containerPort: 8000
name: http
env:
- name: PORT
value: "8000"
envFrom:
- configMapRef:
name: hetairos-config
- secretRef:
name: hetairos-secrets
resources:
requests:
memory: "2Gi"
cpu: "500m"
limits:
memory: "4Gi"
cpu: "1500m"
livenessProbe:
httpGet:
path: /health
port: 8000
initialDelaySeconds: 30
periodSeconds: 10
readinessProbe:
httpGet:
path: /ready
port: 8000
initialDelaySeconds: 10
periodSeconds: 5
imagePullSecrets:
- name: acr-secret
```
## Worker Deployment
```yaml theme={null}
apiVersion: apps/v1
kind: Deployment
metadata:
name: hetairos-worker
namespace: hetairos
labels:
app: hetairos
component: worker
spec:
replicas: 4
selector:
matchLabels:
app: hetairos
component: worker
template:
metadata:
labels:
app: hetairos
component: worker
spec:
containers:
- name: worker
image: your-registry.azurecr.io/hetairos:latest
imagePullPolicy: Always
command: ["python", "run_workers.py"]
envFrom:
- configMapRef:
name: hetairos-config
- secretRef:
name: hetairos-secrets
resources:
requests:
memory: "2Gi"
cpu: "500m"
limits:
memory: "4Gi"
cpu: "1500m"
imagePullSecrets:
- name: acr-secret
```
## Service
```yaml theme={null}
apiVersion: v1
kind: Service
metadata:
name: hetairos-api
namespace: hetairos
labels:
app: hetairos
component: api
spec:
type: ClusterIP
ports:
- port: 80
targetPort: 8000
protocol: TCP
name: http
selector:
app: hetairos
component: api
```
## Ingress
### Using NGINX Ingress
```yaml theme={null}
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: hetairos-ingress
namespace: hetairos
annotations:
kubernetes.io/ingress.class: nginx
cert-manager.io/cluster-issuer: letsencrypt-prod
nginx.ingress.kubernetes.io/ssl-redirect: "true"
spec:
tls:
- hosts:
- hetairos.yourdomain.com
secretName: hetairos-tls
rules:
- host: hetairos.yourdomain.com
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: hetairos-api
port:
number: 80
```
### Using Azure Application Gateway
```yaml theme={null}
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: hetairos-ingress
namespace: hetairos
annotations:
kubernetes.io/ingress.class: azure/application-gateway
appgw.ingress.kubernetes.io/ssl-redirect: "true"
spec:
tls:
- hosts:
- hetairos.yourdomain.com
secretName: hetairos-tls
rules:
- host: hetairos.yourdomain.com
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: hetairos-api
port:
number: 80
```
## Horizontal Pod Autoscaler
### API Autoscaler
```yaml theme={null}
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: hetairos-api-hpa
namespace: hetairos
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: hetairos-api
minReplicas: 2
maxReplicas: 10
metrics:
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 70
- type: Resource
resource:
name: memory
target:
type: Utilization
averageUtilization: 80
```
### Worker Autoscaler
```yaml theme={null}
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: hetairos-worker-hpa
namespace: hetairos
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: hetairos-worker
minReplicas: 4
maxReplicas: 20
metrics:
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 70
- type: Resource
resource:
name: memory
target:
type: Utilization
averageUtilization: 80
```
## Deployment Commands
### Initial Deployment
```bash theme={null}
# Create namespace
kubectl apply -f k8s/namespace.yaml
# Create secrets and config
kubectl apply -f k8s/secrets.yaml
kubectl apply -f k8s/configmap.yaml
# Deploy application
kubectl apply -f k8s/api-deployment.yaml
kubectl apply -f k8s/worker-deployment.yaml
kubectl apply -f k8s/service.yaml
kubectl apply -f k8s/ingress.yaml
# Enable autoscaling
kubectl apply -f k8s/hpa.yaml
```
### Verify Deployment
```bash theme={null}
# Check pods
kubectl get pods -n hetairos
# Check services
kubectl get services -n hetairos
# Check ingress
kubectl get ingress -n hetairos
# View logs
kubectl logs -f deployment/hetairos-api -n hetairos
kubectl logs -f deployment/hetairos-worker -n hetairos
```
## Rolling Updates
### Update Image
```bash theme={null}
# Build new image
docker build -t your-registry.azurecr.io/hetairos:v1.2.0 .
docker push your-registry.azurecr.io/hetairos:v1.2.0
# Update deployment
kubectl set image deployment/hetairos-api \
api=your-registry.azurecr.io/hetairos:v1.2.0 \
-n hetairos
kubectl set image deployment/hetairos-worker \
worker=your-registry.azurecr.io/hetairos:v1.2.0 \
-n hetairos
# Monitor rollout
kubectl rollout status deployment/hetairos-api -n hetairos
kubectl rollout status deployment/hetairos-worker -n hetairos
```
### Rollback
```bash theme={null}
# Rollback if issues
kubectl rollout undo deployment/hetairos-api -n hetairos
kubectl rollout undo deployment/hetairos-worker -n hetairos
```
## Monitoring
### Prometheus ServiceMonitor
```yaml theme={null}
apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
name: hetairos-metrics
namespace: hetairos
spec:
selector:
matchLabels:
app: hetairos
component: api
endpoints:
- port: http
path: /metrics
interval: 30s
```
## Troubleshooting
### Pod Not Starting
```bash theme={null}
# Describe pod
kubectl describe pod -n hetairos
# Check events
kubectl get events -n hetairos --sort-by='.lastTimestamp'
# Check logs
kubectl logs -n hetairos
```
### Connection Issues
```bash theme={null}
# Test service connectivity
kubectl run -it --rm debug --image=busybox --restart=Never -- sh
wget -O- http://hetairos-api.hetairos.svc.cluster.local
# Check endpoints
kubectl get endpoints -n hetairos
```
### Resource Issues
```bash theme={null}
# Check resource usage
kubectl top nodes
kubectl top pods -n hetairos
# Describe node
kubectl describe node
```
## Best Practices
1. **Use resource limits** - Prevent pods from consuming too many resources
2. **Health checks** - Implement liveness and readiness probes
3. **Rolling updates** - Zero-downtime deployments
4. **Autoscaling** - Handle variable load
5. **Monitoring** - Track metrics and logs
6. **Security** - Use RBAC, network policies, pod security policies
7. **Secrets management** - Use Key Vault or external secrets
8. **Multiple environments** - Separate dev, staging, production
## Next Steps
Configure Praxos settings
Review deployment requirements
# Deployment Requirements
Source: https://docs.mypraxos.com/deployment/requirements
Prerequisites and requirements for deploying Praxos
## Overview
This guide covers the infrastructure and software requirements for deploying Praxos to production.
## System Requirements
### Minimum Specifications
For small deployments (1-10 users):
* **CPU**: 2 cores
* **RAM**: 4 GB
* **Storage**: 20 GB
* **Network**: Stable internet connection
### Recommended Specifications
For production (10-100 users):
* **CPU**: 4-8 cores
* **RAM**: 8-16 GB
* **Storage**: 50-100 GB SSD
* **Network**: High-bandwidth, low-latency
### High-Scale Specifications
For enterprise (100+ users):
* **CPU**: 16+ cores (distributed)
* **RAM**: 32+ GB (per pod)
* **Storage**: 500+ GB SSD
* **Network**: Load balanced, redundant
## Software Dependencies
### Required
* **Python**: 3.11 or higher
* **Docker**: 20.10 or higher (for containerized deployment)
* **Kubernetes**: 1.24+ (for orchestration)
* **MongoDB**: 4.4+ or Azure Cosmos DB
### Optional
* **Redis**: 6.0+ (for local queue, alternative to Azure Service Bus)
* **NGINX**: Load balancing and SSL termination
* **Prometheus**: Monitoring and metrics
* **Grafana**: Visualization
## Cloud Services
### Azure (Recommended)
* **Azure Kubernetes Service (AKS)** - Container orchestration
* **Azure Cosmos DB** - Primary database
* **Azure Service Bus** - Message queue
* **Azure Key Vault** - Secrets management
* **Azure Container Registry** - Docker images
* **Azure Storage** - Blob storage
* **Application Insights** - Monitoring
### AWS (Alternative)
* **EKS** - Kubernetes
* **DocumentDB** - MongoDB compatible
* **SQS** - Message queue
* **Secrets Manager** - Secrets
* **ECR** - Container registry
* **S3** - Object storage
* **CloudWatch** - Monitoring
### GCP (Alternative)
* **GKE** - Kubernetes
* **Cloud Firestore** or **MongoDB Atlas** - Database
* **Cloud Tasks** - Message queue
* **Secret Manager** - Secrets
* **Container Registry** - Images
* **Cloud Storage** - Object storage
* **Cloud Monitoring** - Observability
## Database Requirements
### MongoDB
**Minimum:**
* Version: 4.4+
* Storage: 10 GB
* RAM: 4 GB
* Connection pooling: 100 connections
**Recommended:**
* Version: 6.0+
* Storage: 50+ GB SSD
* RAM: 8+ GB
* Replica set with 3 nodes
* Connection pooling: 500 connections
**Collections:**
* users
* conversations
* user\_context
* integrations
* tasks
* logs
### Azure Cosmos DB
**Configuration:**
* API: MongoDB
* Throughput: 1000 RU/s minimum
* Consistency: Session (default)
* Multi-region: Recommended for HA
## Message Queue
### Azure Service Bus
**Configuration:**
* Tier: Standard or Premium
* Queues: agent\_tasks, scheduled\_tasks
* Topic/Subscriptions: Optional for pub/sub
* Max message size: 256 KB
* Message TTL: 14 days
### Redis (Alternative)
**Configuration:**
* Version: 6.0+
* Memory: 2-8 GB
* Persistence: RDB + AOF
* Cluster mode: For high availability
## API Keys & Credentials
### Required
* **LLM Provider**
* Portkey API Key
* OpenAI API Key (primary)
* Google AI API Key (secondary)
* **Database**
* MongoDB connection string
* Or Azure Cosmos DB endpoint + key
* **Message Queue**
* Azure Service Bus connection string
* Or Redis connection URL
### Integration-Specific
Configure based on enabled integrations:
* **Telegram**: Bot token
* **Discord**: Bot token, Application ID
* **Slack**: Bot token, Signing secret
* **Google**: Client ID, Client Secret
* **Microsoft**: Client ID, Client Secret, Tenant ID
* **Notion**: Integration token
* **Trello**: API key, Token
## Networking Requirements
### Inbound
* **Port 8000**: HTTP/HTTPS (API)
* **Port 443**: HTTPS (webhooks)
### Outbound
Must allow connections to:
* LLM providers (OpenAI, Google)
* Integration APIs (Google, Microsoft, Telegram, etc.)
* Database servers
* Message queue services
### Webhooks
Public HTTPS endpoint required for:
* Telegram webhooks
* Discord webhooks
* Slack events
* Google Calendar notifications
* Microsoft Graph subscriptions
## SSL/TLS
### Requirements
* Valid SSL certificate
* TLS 1.2 or higher
* HTTPS for all external endpoints
### Options
* Let's Encrypt (free)
* Commercial certificate
* Cloud provider managed certificate
* Kubernetes cert-manager
## Domain & DNS
### Domain Requirements
* Production domain (e.g., hetairos.yourcompany.com)
* Optional: Separate domains per environment
### DNS Records
```
A record: hetairos.yourcompany.com → Load Balancer IP
CNAME: www.hetairos.yourcompany.com → hetairos.yourcompany.com
```
## Storage Requirements
### Application Storage
* Docker images: 2-5 GB
* Logs: 10-50 GB (with rotation)
* Temporary files: 5-10 GB
### Database Storage
* User data: \~10 MB per active user
* Conversation history: \~50 MB per active user
* Growth rate: \~5-10 GB/month (100 users)
## Monitoring & Logging
### Metrics Collection
* CPU and memory usage
* Request latency
* Error rates
* Queue depth
* Database performance
### Log Aggregation
* Application logs
* Error logs
* Access logs
* Audit logs
### Tools
* **Prometheus**: Metrics
* **Grafana**: Dashboards
* **ELK Stack**: Logs (Elasticsearch, Logstash, Kibana)
* **Azure Monitor**: All-in-one (if using Azure)
## Backup & Disaster Recovery
### Database Backups
* Frequency: Daily (minimum)
* Retention: 30 days (minimum)
* Point-in-time recovery: Enabled
* Cross-region replication: Recommended
### Configuration Backups
* Environment variables
* Kubernetes manifests
* SSL certificates
* Integration credentials
### RTO/RPO Targets
**Recommended:**
* RTO (Recovery Time Objective): \< 4 hours
* RPO (Recovery Point Objective): \< 1 hour
## Security Requirements
### Authentication & Authorization
* Service account authentication
* Role-based access control (RBAC)
* API key rotation
* Secret management
### Data Protection
* Encryption at rest (database, storage)
* Encryption in transit (TLS)
* Secrets in Key Vault/Secrets Manager
* No credentials in code or config files
### Compliance
Consider requirements for:
* GDPR (EU users)
* CCPA (California users)
* SOC 2 (enterprise)
* HIPAA (healthcare)
## Scalability Considerations
### Horizontal Scaling
* Stateless workers
* Load balancing
* Auto-scaling based on:
* CPU usage
* Memory usage
* Queue depth
### Vertical Scaling
* Increase pod resources
* Database tier upgrades
* Message queue tier upgrades
### Performance Targets
* Message processing: \< 5 seconds (simple)
* API response time: \< 500ms (p95)
* Concurrent users: 100+ per pod
* Queue throughput: 100+ messages/sec
## Cost Estimation
### Small Deployment (10 users)
* Compute: \$50-100/month
* Database: \$25-50/month
* Queue: \$10-25/month
* LLM API: \$50-200/month
* **Total**: \~\$150-400/month
### Medium Deployment (50 users)
* Compute: \$200-400/month
* Database: \$100-200/month
* Queue: \$25-50/month
* LLM API: \$250-1000/month
* **Total**: \~\$600-1700/month
### Large Deployment (100+ users)
* Compute: \$500-1000/month
* Database: \$300-600/month
* Queue: \$50-100/month
* LLM API: \$500-2500/month
* **Total**: \~\$1400-4200/month
Costs vary significantly based on usage patterns, enabled integrations, and cloud provider.
## Pre-Deployment Checklist
* [ ] Cloud infrastructure provisioned
* [ ] Database created and configured
* [ ] Message queue set up
* [ ] Secrets stored in Key Vault
* [ ] Domain and SSL configured
* [ ] Monitoring and logging enabled
* [ ] Backup strategy implemented
* [ ] Load balancer configured
* [ ] Network security rules set
* [ ] API keys obtained for all integrations
* [ ] Deployment manifests prepared
* [ ] CI/CD pipeline configured (optional)
## Next Steps
Deploy Praxos to Kubernetes
Configure Praxos for your environment
# Architecture
Source: https://docs.mypraxos.com/guides/architecture
Understanding Praxos's system architecture and design
## System Overview
Praxos is built as a modular, event-driven AI assistant platform that integrates with multiple communication channels and external services.
```mermaid theme={null}
graph TB
A[User] -->|Messages| B[Ingress Layer]
B -->|Telegram| C[Message Queue]
B -->|Discord| C
B -->|Slack| C
B -->|WhatsApp| C
C -->|Tasks| D[Worker Pool]
D -->|Process| E[LangGraph Agent]
E -->|Uses| F[Tool Factory]
F -->|Creates| G[Integration Tools]
F -->|Creates| H[Communication Tools]
F -->|Creates| I[Database Tools]
E -->|Responses| J[Egress Layer]
J -->|Sends| A
```
## Core Components
### Ingress Layer
The ingress layer handles incoming messages from various platforms:
* **FastAPI Server** (`src/ingress/api.py`) - Main HTTP/WebSocket server
* **Platform Adapters** - Telegram, Discord, Slack, WhatsApp adapters
* **Message Validation** - Input sanitization and validation
* **Queue Publishing** - Pushes messages to processing queue
### Message Queue
Uses Azure Service Bus (or Redis in local mode) for:
* Asynchronous message processing
* Load balancing across workers
* Retry mechanisms for failed tasks
* Priority-based task scheduling
### Worker Pool
Background workers (`src/workers/`) process tasks:
* **Agent Workers** - Run LangGraph agent loops
* **Scheduled Task Workers** - Execute recurring tasks
* **Ingestion Workers** - Process files and documents
* Auto-scaling based on queue depth
### LangGraph Agent
The core AI orchestration engine:
```python theme={null}
# Simplified agent flow
State -> Tool Selection -> Tool Execution -> State Update -> Response
```
Key features:
* Multi-step reasoning with LangGraph
* Conversational memory and context
* Dynamic tool selection
* Interrupt handling for long operations
### Tool Factory
Dynamically creates tools based on user context:
* **Integration Tools** - Google, Microsoft, Notion, etc.
* **Communication Tools** - Send messages, intermediate updates
* **Database Tools** - User preferences, context storage
* **Web Tools** - Browsing, search, content extraction
* **Utility Tools** - File processing, scheduling
## Data Flow
### Message Processing Flow
1. **Receive Message**
* User sends message via platform (Telegram, Discord, etc.)
* Platform webhook hits ingress endpoint
* Message validated and normalized
2. **Queue & Route**
* Message published to Azure Service Bus
* Worker picks up message from queue
* Worker loads user context from database
3. **Agent Processing**
* LangGraph agent initialized with tools
* Agent reasons about task
* Agent executes tools as needed
* Intermediate updates sent to user
4. **Response Delivery**
* Final response formatted for platform
* Egress layer sends message
* State saved to database
### Tool Execution Pattern
```python theme={null}
# Example tool execution
async def send_email(to: str, subject: str, body: str):
# 1. Validate inputs
# 2. Load user's email credentials
# 3. Send via Gmail/Outlook API
# 4. Return execution status
return ToolExecutionResponse(status="success", result="Email sent")
```
## Technology Stack
### Backend
* **Python 3.11+** - Core runtime
* **FastAPI** - Web framework
* **LangGraph** - Agent orchestration
* **Pydantic** - Data validation
* **Motor** - Async MongoDB driver
### AI & LLM
* **Portkey** - LLM gateway for routing
* **OpenAI** - Primary LLM provider
* **Google Gemini** - Alternative LLM provider
* **LangChain** - LLM abstractions and utilities
### Infrastructure
* **Docker** - Containerization
* **Kubernetes** - Orchestration
* **Azure Service Bus** - Message queue
* **Azure Cosmos DB** - Document database
* **Azure Key Vault** - Secrets management
### Web Automation
* **Playwright** - Browser automation
* **browser-use** - AI-powered browsing library
* **BeautifulSoup** - HTML parsing
## Design Principles
### Modularity
Each integration and tool is self-contained:
```
src/
integrations/
telegram/
adapter.py # Platform-specific logic
handler.py # Message handling
sender.py # Message sending
```
### Extensibility
Adding new integrations is straightforward:
1. Create new integration module
2. Implement base adapter interface
3. Register with tool factory
4. Configure credentials
### Scalability
* Stateless workers for horizontal scaling
* Queue-based architecture for load distribution
* Async operations throughout
* Efficient caching strategies
### Reliability
* Automatic retry logic for transient failures
* Dead letter queues for failed messages
* Health checks and monitoring
* Graceful degradation
## Configuration Management
### Environment-Based Config
```python theme={null}
# src/config/settings.py
class Settings:
environment: str # development, staging, production
mongodb_uri: str
azure_keyvault_url: str
# ... more settings
```
### Secrets Management
Production secrets stored in Azure Key Vault:
* API tokens
* Database credentials
* Integration credentials
### Feature Flags
Enable/disable features per user:
* Beta feature access
* Tool availability
* Rate limiting
## Monitoring & Observability
### Logging
Structured logging throughout:
```python theme={null}
logger.info("Agent processing message", extra={
"user_id": user_id,
"platform": "telegram",
"message_id": msg_id
})
```
### Metrics
Key metrics tracked:
* Message processing time
* Tool execution success rate
* Queue depth
* Error rates by type
### Tracing
Distributed tracing for request flows:
* End-to-end message journey
* Tool execution times
* External API calls
## Security
### Authentication
* Platform-specific auth (bot tokens, OAuth)
* User identity verification
* Session management
### Authorization
* User-level permissions
* Integration access control
* Tool usage policies
### Data Protection
* Encryption at rest (Cosmos DB)
* Encryption in transit (TLS)
* Credential isolation per user
* PII handling compliance
## Performance Considerations
### Caching Strategy
* User context cached in-memory (TTL: 5 min)
* Integration credentials cached (TTL: 1 hour)
* Common responses cached
### Resource Management
* Connection pooling for databases
* Rate limiting on external APIs
* Memory limits per worker
* Timeout handling for long operations
### Optimization
* Lazy loading of integrations
* Async/await throughout
* Bulk operations where possible
* Efficient serialization
## Future Enhancements
Planned architectural improvements:
* **Multi-tenant Support** - Isolated environments per organization
* **Plugin System** - User-installable tools and integrations
* **Event Streaming** - Real-time analytics with Kafka/Event Hub
* **Edge Deployment** - Regional workers for lower latency
* **GraphQL API** - Flexible data querying
# Calendar Management
Source: https://docs.mypraxos.com/guides/calendar
Schedule events and manage your time with Praxos
## Overview
Praxos provides comprehensive calendar management across Google Calendar and Microsoft Outlook Calendar.
## Capabilities
* Create events and meetings
* Check your schedule
* Find available time slots
* Update and delete events
* Invite attendees
* Set reminders
* Manage recurring events
## Creating Events
### Simple Event
```
User: Schedule lunch tomorrow at 1pm
Praxos: ✓ Created event "Lunch"
Tomorrow, 1:00 PM - 2:00 PM
[View in Calendar]
```
### Meeting with Attendees
```
User: Schedule a meeting with john@company.com and
sarah@company.com next Tuesday at 3pm for 1 hour
Praxos: ✓ Created meeting
Title: Meeting
When: Tue, Oct 15, 3:00 PM - 4:00 PM
Attendees: john@company.com, sarah@company.com
Meeting invites sent ✓
```
### Detailed Event
```
User: Create a calendar event:
- Title: Q4 Planning Session
- Tomorrow 2-4pm
- Location: Conference Room A
- Add mike@company.com
Praxos: ✓ Created "Q4 Planning Session"
Tomorrow, 2:00 PM - 4:00 PM
Location: Conference Room A
Attendee: mike@company.com
Reminder: 15 minutes before
```
## Checking Schedule
### Today's Schedule
```
User: What's on my calendar today?
Praxos: Today's schedule (Oct 10, 2024):
9:00 AM - 9:30 AM
Daily Standup
11:00 AM - 12:00 PM
Client Review Meeting
With: client@external.com
2:00 PM - 3:00 PM
Sprint Planning
4:00 PM - 4:30 PM
1-on-1 with Manager
You have 4 events today.
```
### Specific Day
```
User: What do I have scheduled for next Monday?
Praxos: Schedule for Mon, Oct 14:
10:00 AM - 11:00 AM
Team Sync
1:00 PM - 2:00 PM
Lunch with John
3:00 PM - 5:00 PM
Workshop: New Tools
3 events scheduled.
```
### Date Range
```
User: Show my calendar for this week
Praxos: This week (Oct 10-16):
Mon: 3 events
Tue: 5 events
Wed: 2 events
Thu: 4 events
Fri: 2 events
Total: 16 events
[Show details] [Export]
```
## Finding Available Time
### Personal Availability
```
User: When am I free tomorrow?
Praxos: Available times tomorrow (Oct 11):
9:00 AM - 11:00 AM
1:00 PM - 3:00 PM
4:00 PM - 6:00 PM
Total: 5 hours available
```
### Meeting Scheduling
```
User: Find a 30-minute slot when John, Sarah, and I are all free this week
Praxos: Checking calendars...
All available:
• Wed, 2:00 PM - 3:00 PM
• Thu, 10:00 AM - 12:00 PM
• Fri, 11:00 AM - 12:00 PM
[Schedule for Wed 2pm] [Other times]
```
### Specific Constraints
```
User: When can I schedule a 2-hour meeting this week in the afternoon?
Praxos: 2-hour afternoon slots available:
Tue: 2:00 PM - 4:00 PM
Wed: 1:00 PM - 3:00 PM
Thu: 3:00 PM - 5:00 PM
[Schedule] [See more times]
```
## Managing Events
### Update Event
```
User: Move tomorrow's team meeting from 2pm to 3pm
Praxos: ✓ Updated "Team Meeting"
New time: Tomorrow, 3:00 PM - 4:00 PM
Updated invites sent to 5 attendees
```
### Cancel Event
```
User: Cancel my 4pm meeting today
Praxos: Found event: "1-on-1 with Manager" at 4:00 PM
Cancel this event?
User: Yes
Praxos: ✓ Event cancelled
Cancellation notice sent to attendees
```
### Add Attendees
```
User: Add alice@company.com to tomorrow's planning meeting
Praxos: ✓ Added alice@company.com to "Planning Meeting"
Meeting invite sent
```
## Recurring Events
### Create Recurring
```
User: Schedule a daily standup at 9am on weekdays
Praxos: ✓ Created recurring event
"Daily Standup"
Every weekday at 9:00 AM
Duration: 30 minutes
Starting: Tomorrow
```
### Modify Series
```
User: Change all future standups to 9:30am
Praxos: ✓ Updated recurring event
New time: 9:30 AM (weekdays)
Applies to: All future instances
```
## Reminders
### Set Reminder
```
User: Remind me 30 minutes before my next meeting
Praxos: ✓ Set 30-minute reminder for "Client Review"
You'll be notified at 10:30 AM
```
### Default Reminders
Configure default reminders:
* 15 minutes before (default)
* 1 hour before
* 1 day before
* Custom timing
## Time Zones
### Time Zone Aware
```
User: Schedule call with Tokyo office at 9am their time
Praxos: Tokyo is currently JST (UTC+9)
9:00 AM JST = 5:00 PM PDT (your time)
Schedule for:
Today, 5:00 PM PDT (9:00 AM JST tomorrow)?
User: Yes
Praxos: ✓ Created "Call with Tokyo Office"
Today, 5:00 PM - 6:00 PM PDT
Note: 9:00 AM - 10:00 AM JST
```
### Multi-Zone Display
```
User: What time is my 2pm meeting in London time?
Praxos: Your meeting at 2:00 PM PDT is:
• 10:00 PM BST (London)
• 6:00 PM EDT (New York)
• 11:00 PM CEST (Paris)
```
## Integration-Specific Features
### Google Calendar
* Multiple calendar support
* Color coding
* Event attachments
* Meet links auto-generation
* Rich descriptions
### Microsoft Outlook
* Teams meeting integration
* Room booking
* Response tracking
* Category management
* Shared calendars
## Smart Features
### Conflict Detection
```
User: Schedule team meeting tomorrow at 2pm
Praxos: ⚠️ Conflict detected
You already have "Client Call" at 2:00 PM
Available nearby times:
• 1:00 PM - 2:00 PM
• 3:00 PM - 4:00 PM
[Schedule anyway] [Pick new time]
```
### Buffer Time
```
User: I need 15-minute breaks between meetings
Praxos: ✓ Applied 15-minute buffer preference
When scheduling, I'll ensure:
- No back-to-back meetings
- 15 minutes between events
```
### Travel Time
```
User: Add 30 minutes travel time before in-person meetings
Praxos: ✓ Will account for travel time
For meetings with location:
- Block 30 min before
- Suggest earlier departure
```
## Configuration
### Preferences
Set your calendar preferences:
* Default event duration (1 hour)
* Working hours (9am-5pm)
* Default reminders
* Time zone
* Week start day
### Multiple Calendars
Manage multiple calendars:
* Work calendar (primary)
* Personal calendar
* Team calendars
* Shared calendars
```
User: Add this to my personal calendar, not work
Praxos: ✓ Created in "Personal Calendar"
[Move to another calendar]
```
## Advanced Usage
### Conditional Scheduling
```
User: Schedule review meeting next week only if the project is done
Praxos: ✓ Created conditional event
"Project Review"
Tentative: Next week TBD
Condition: Project completion
I'll remind you to confirm once project status is known
```
### Batch Operations
```
User: Cancel all my meetings tomorrow
Praxos: Found 5 meetings tomorrow:
• 9:00 AM - Daily Standup
• 11:00 AM - Client Call
• 2:00 PM - Team Sync
• 3:00 PM - Planning
• 4:00 PM - 1-on-1
Cancel all 5 meetings?
User: Yes, except the client call
Praxos: ✓ Cancelled 4 meetings
Kept: Client Call at 11:00 AM
Cancellation notices sent
```
## Troubleshooting
### Calendar Not Syncing
* Check integration connection
* Verify OAuth tokens are valid
* Re-authenticate if needed
* Check calendar permissions
### Events Not Appearing
* Confirm correct calendar selected
* Check date/time range
* Verify time zone settings
* Refresh calendar view
### Permission Errors
* Ensure calendar write permissions
* Check shared calendar access
* Verify attendee email addresses
## Best Practices
* Use clear, descriptive event titles
* Always include relevant attendees
* Set appropriate reminders
* Add locations for in-person meetings
* Include agenda in description
* Respect others' availability
## Next Steps
# Email Management
Source: https://docs.mypraxos.com/guides/email
Send, read, and organize emails with Praxos
## Overview
Praxos helps you manage email across Gmail and Microsoft Outlook with intelligent features for reading, sending, searching, and organizing messages.
## Capabilities
* Send emails
* Read and search emails
* Organize with labels/folders
* Filter and sort
* Attachments
* Drafts management
* Batch operations
## Sending Emails
### Simple Email
```
User: Send an email to john@company.com
Praxos: What should the subject and message be?
User: Subject: Team Update
Message: Hey John, just wanted to share the latest...
Praxos: ✓ Email sent to john@company.com
Subject: Team Update
[View sent email]
```
### Quick Send
```
User: Email sarah@company.com about the meeting tomorrow at 2pm
Praxos: ✓ Sent email to sarah@company.com
Subject: Meeting Tomorrow
Content: Hi Sarah, reminder that we have a
meeting tomorrow at 2:00 PM. Looking forward to it!
```
### Multiple Recipients
```
User: Send email to team@company.com and boss@company.com
Subject: Project Complete
Message: [your message]
Praxos: ✓ Email sent to 2 recipients:
• team@company.com
• boss@company.com
Subject: Project Complete
```
### With Attachments
```
User: [Sends file] Email this report to stakeholders@company.com
Praxos: ✓ Email sent with attachment
To: stakeholders@company.com
Subject: Report
Attachment: Q4_Report.pdf (2.3 MB)
```
## Reading Emails
### Recent Emails
```
User: Show my recent emails
Praxos: Recent emails (last 10):
1. Sarah Chen - Re: Project Update
2 minutes ago
2. GitHub - Pull Request #234
15 minutes ago
3. Boss - Team Meeting Tomorrow
1 hour ago
[...]
[Show more] [Filter]
```
### Unread Emails
```
User: What are my unread emails?
Praxos: You have 12 unread emails:
Priority:
• Boss - Q4 Goals (2 hours ago) ⭐
• Client - Contract Review (5 hours ago) ⭐
Other:
• Newsletter - Tech Updates (1 day ago)
• LinkedIn - Connection request
[...]
[Mark all read] [Show details]
```
### Read Specific Email
```
User: Show me the email from Sarah about the project
Praxos: Email from Sarah Chen:
From: sarah@company.com
Subject: Re: Project Update
Date: Oct 10, 2024, 2:30 PM
Hi! Just wanted to update you on the project
status. We've completed phase 1 and are moving
into phase 2. The timeline looks good...
[Reply] [Forward] [Archive]
```
## Searching Emails
### By Sender
```
User: Find all emails from boss@company.com from last week
Praxos: Found 8 emails from boss@company.com (Oct 3-10):
1. Team Meeting Tomorrow (Oct 9)
2. Q4 Goals (Oct 8)
3. Budget Approval Needed (Oct 7)
[...]
[Show full list] [Filter more]
```
### By Subject
```
User: Search for emails about "budget"
Praxos: Found 15 emails matching "budget":
Recent:
• Budget Approval (Oct 9) - Boss
• Q4 Budget Planning (Oct 7) - Finance
• Budget Review Meeting Notes (Oct 5) - Sarah
[Show all 15] [Sort by date]
```
### By Content
```
User: Find emails mentioning "deadline extension"
Praxos: Found 3 emails with "deadline extension":
1. Re: Project Timeline (Oct 8)
From: client@external.com
"...approve the deadline extension request..."
2. Team Update (Oct 6)
From: manager@company.com
"...considering deadline extension due to..."
[Read full emails]
```
### Date Range
```
User: Show emails from last month
Praxos: Emails from Sep 10 - Oct 10:
Total: 347 emails
Top senders:
• GitHub (87 emails)
• Team list (43 emails)
• Boss (23 emails)
[Filter] [Search within]
```
### Combined Filters
```
User: Find unread emails from this week about "meeting"
Praxos: Found 4 unread emails this week about "meeting":
1. Team Meeting Tomorrow (Today)
From: boss@company.com
2. Meeting Notes Request (Yesterday)
From: sarah@company.com
[Show details] [Mark as read]
```
## Organizing Emails
### Labels (Gmail)
```
User: Label the email from Sarah as "Project Alpha"
Praxos: ✓ Added label "Project Alpha"
Email: Re: Project Update
User: Show all emails with label "Project Alpha"
Praxos: 23 emails labeled "Project Alpha"
Most recent:
• Project Update (Today)
• Weekly Status (Yesterday)
• Meeting Notes (Oct 8)
[...]
```
### Folders (Outlook)
```
User: Move this email to the "Projects" folder
Praxos: ✓ Moved to "Projects" folder
Email: Re: Project Update
User: What's in my Projects folder?
Praxos: "Projects" folder contains 45 emails
[Show contents]
```
### Archive
```
User: Archive all emails from last month
Praxos: Found 347 emails from last month
Archive all 347 emails?
User: Yes, except ones from my boss
Praxos: ✓ Archived 324 emails
Kept: 23 emails from boss@company.com
```
### Delete
```
User: Delete all emails from "newsletter@marketing.com"
Praxos: Found 87 emails from newsletter@marketing.com
⚠️ This will permanently delete 87 emails
Confirm deletion?
User: Yes
Praxos: ✓ Deleted 87 emails
```
## Email Actions
### Reply
```
User: Reply to Sarah's email: "Sounds great! Let's schedule a meeting."
Praxos: ✓ Sent reply to sarah@company.com
Re: Project Update
```
### Reply All
```
User: Reply all to the team email with status update
Praxos: Reply to all 5 recipients?
• team@company.com
• john@company.com
• sarah@company.com
• mike@company.com
• boss@company.com
User: Yes
Praxos: ✓ Reply sent to all recipients
```
### Forward
```
User: Forward the budget email to finance@company.com
Praxos: ✓ Forwarded to finance@company.com
Subject: Fwd: Q4 Budget Planning
[View forwarded email]
```
### Mark as Read/Unread
```
User: Mark all emails from GitHub as read
Praxos: ✓ Marked 23 GitHub emails as read
User: Mark the boss's email as unread so I remember to reply
Praxos: ✓ Marked as unread
"Q4 Goals" - boss@company.com
```
## Drafts
### Create Draft
```
User: Draft an email to client@external.com about project delay
Praxos: I'll help you draft that. What should I mention?
User: [Provides details]
Praxos: ✓ Created draft
To: client@external.com
Subject: Project Timeline Update
[Review] [Edit] [Send] [Discard]
```
### Edit Draft
```
User: Show my drafts
Praxos: You have 3 drafts:
1. Project Timeline Update (5 min ago)
2. Meeting Follow-up (2 hours ago)
3. Budget Proposal (Yesterday)
[Open] [Send] [Delete]
```
## Filters and Rules
### Auto-Label
```
User: Automatically label all emails from github.com as "Code"
Praxos: ✓ Created filter rule
When: From github.com
Action: Apply label "Code"
Apply to existing emails? [Yes] [No]
```
### Auto-Archive
```
User: Auto-archive newsletters after 7 days
Praxos: ✓ Created filter rule
When: Label = "Newsletter"
AND Age > 7 days
Action: Archive
This will run automatically
```
## Smart Features
### Summary
```
User: Summarize my unread emails
Praxos: Unread email summary (12 emails):
🚨 Urgent (2):
• Boss - Q4 Goals review needed
• Client - Contract signature required
📅 Meetings (3):
• Team sync tomorrow 10am
• 1-on-1 with Sarah Friday 2pm
• Client call next week
ℹ️ Info (7):
• Project updates, newsletters, notifications
```
### Important Detection
```
User: What are my important emails today?
Praxos: Important emails detected:
⭐ High Priority:
• Boss - Urgent: Budget approval needed
• Client - Decision required on proposal
Based on:
- Sender importance
- Keywords
- Previous interactions
```
### Follow-up Reminders
```
User: Remind me to follow up on the client email if they don't reply
Praxos: ✓ Set follow-up reminder
Email: Proposal to client@external.com
If no reply by: Oct 13 (3 days)
I'll remind you to follow up
```
## Attachments
### Download
```
User: Download the PDF from yesterday's email from John
Praxos: Found attachment: Q3_Report.pdf
From: john@company.com (Yesterday)
[Download] [Preview] [Save to Drive]
```
### Search by Attachment
```
User: Find emails with PDF attachments from this month
Praxos: Found 12 emails with PDF attachments:
1. Q3_Report.pdf - John (Yesterday)
2. Contract_v2.pdf - Legal (Oct 8)
3. Proposal.pdf - Sarah (Oct 5)
[...]
```
## Batch Operations
```
User: Archive all read emails older than 30 days
Praxos: Found 234 read emails older than 30 days
Total size: 156 MB
Archive all?
User: Yes
Praxos: ✓ Archived 234 emails
Freed up 156 MB
Emails moved to Archive
```
## Configuration
### Preferences
* Signature
* Default font
* Reply behavior
* Attachment settings
* Auto-responses
### Multiple Accounts
```
User: Send from my personal email instead of work
Praxos: Sending from: personal@gmail.com
(instead of work@company.com)
✓ Email sent
```
## Troubleshooting
### Can't Send Email
* Check recipient email address
* Verify attachment size limits
* Confirm email permissions
* Check for authentication issues
### Emails Not Appearing
* Check filter/search criteria
* Verify correct account
* Check spam/trash folders
* Sync may be delayed
## Best Practices
* Use clear subject lines
* Keep emails concise
* Archive regularly
* Use labels/folders for organization
* Unsubscribe from unwanted emails
* Set up filters for automation
## Next Steps
# File Management
Source: https://docs.mypraxos.com/guides/file-management
Access, upload, and manage files across cloud storage
## Overview
Praxos helps you manage files across Google Drive, OneDrive, and Dropbox with intelligent search, organization, and processing capabilities.
## Supported Platforms
* **Google Drive** - Full integration
* **OneDrive** - Microsoft cloud storage
* **Dropbox** - File storage and sharing
## Capabilities
* Search and find files
* Upload and download
* Share files
* Organize with folders
* Process documents (PDF, Word, Excel)
* Extract text and metadata
* OCR for images
## Searching Files
### Simple Search
```
User: Find my Q4 report
Praxos: Found "Q4_Financial_Report.pdf"
Location: Google Drive > Work > Reports
Last modified: Oct 5, 2024
Size: 2.3 MB
[Open] [Download] [Share]
```
### By File Type
```
User: Find all Excel files in my Drive
Praxos: Found 23 Excel files:
Recent:
• Budget_2024.xlsx (Today)
• Sales_Data.xlsx (Yesterday)
• Inventory.xlsx (Oct 8)
[Show all] [Sort by size] [Filter]
```
### By Date
```
User: Show files modified this week
Praxos: Files modified this week (34 files):
Today (5):
• Presentation.pptx
• Notes.docx
[...]
This week (29):
• Report_Draft.pdf
• Data_Analysis.xlsx
[...]
```
### By Location
```
User: What's in my "Projects" folder?
Praxos: "Projects" folder contains:
Folders (3):
• Project_Alpha
• Project_Beta
• Archive
Files (12):
• Overview.docx
• Timeline.xlsx
• Budget.pdf
[...]
Total: 3 folders, 12 files (45 MB)
```
## Uploading Files
### Simple Upload
```
User: [Sends file]
Praxos: Received "presentation.pptx" (5.2 MB)
Upload to Google Drive?
User: Yes
Praxos: ✓ Uploaded to Google Drive
Location: My Drive/
[View in Drive] [Move to folder]
```
### To Specific Location
```
User: [Sends file] Save this to my Projects folder
Praxos: ✓ Uploaded "design_mockup.png"
Location: Google Drive > Projects/
Size: 1.8 MB
[Open] [Share]
```
### Multiple Files
```
User: [Sends 3 files]
Praxos: Received 3 files (8.7 MB total):
• document1.pdf
• document2.pdf
• spreadsheet.xlsx
Upload all to Google Drive?
User: Yes
Praxos: ✓ Uploaded 3 files
Location: My Drive/
Total size: 8.7 MB
```
## Downloading Files
### Simple Download
```
User: Download my Q4 report
Praxos: Found "Q4_Financial_Report.pdf"
[Sends file]
Size: 2.3 MB
```
### By Search
```
User: Get the latest version of the budget spreadsheet
Praxos: Found "Budget_2024_v3.xlsx"
Last modified: Today, 2:30 PM
[Sends file]
Size: 456 KB
```
## Sharing Files
### Create Share Link
```
User: Share my presentation with the team
Praxos: Found "Q4_Presentation.pptx"
Created share link:
https://drive.google.com/file/d/abc123...
Access: Anyone with link can view
[Copy link] [Change permissions] [Send via email]
```
### Share with Specific People
```
User: Share the budget file with sarah@company.com
Praxos: ✓ Shared "Budget_2024.xlsx"
With: sarah@company.com
Permission: Can edit
Notification sent ✓
```
### Change Permissions
```
User: Make my report view-only
Praxos: ✓ Updated permissions for "Q4_Report.pdf"
Access: Anyone with link can view
Editing: Disabled
```
## File Organization
### Create Folder
```
User: Create a folder called "Q4 Projects"
Praxos: ✓ Created folder "Q4 Projects"
Location: Google Drive > My Drive/
[Open folder] [Move files to folder]
```
### Move Files
```
User: Move all PDFs from My Drive to the Reports folder
Praxos: Found 12 PDF files in My Drive
Move all to Reports folder?
User: Yes
Praxos: ✓ Moved 12 PDFs to Reports/
[View folder]
```
### Rename
```
User: Rename "doc1.pdf" to "Final_Report.pdf"
Praxos: ✓ Renamed file
Old: doc1.pdf
New: Final_Report.pdf
Location: Reports/
```
### Delete
```
User: Delete all files older than 1 year
Praxos: ⚠️ Found 87 files older than 1 year
Total size: 234 MB
These will be moved to Trash
Delete all?
User: Yes
Praxos: ✓ Moved 87 files to Trash
Freed up: 234 MB
[Empty trash] [Restore]
```
## Document Processing
### Extract Text from PDF
```
User: [Sends PDF] What does this document say?
Praxos: Processing "Contract.pdf"...
Document Summary:
- 12 pages
- Contract type: Service Agreement
- Parties: Company A and Company B
- Term: 2 years starting Jan 1, 2025
- Value: $50,000 annually
Key sections:
1. Scope of Work (pages 1-3)
2. Payment Terms (pages 4-5)
3. Termination Clause (page 8)
[Show full text] [Ask questions]
```
### Extract from Images (OCR)
```
User: [Sends image of receipt]
Praxos: Processing image with OCR...
Receipt Details:
Store: Coffee Shop
Date: Oct 10, 2024
Total: $12.50
Items:
- Latte: $5.00
- Sandwich: $7.50
[Export to spreadsheet] [Save to expenses]
```
### Word Document Analysis
```
User: [Sends .docx] Summarize this document
Praxos: Analyzing "Proposal.docx"...
Document: Project Proposal
Length: 2,450 words, 8 pages
Sections: 6
Summary:
Proposal for new customer portal development.
Timeline: 3 months, Budget: $75K
Team: 5 developers, 1 designer
Key features: Dashboard, reporting, mobile app
[Ask questions] [Extract specific section]
```
### Excel Processing
```
User: [Sends .xlsx] What's the total in column C?
Praxos: Processing "Sales_Data.xlsx"...
Sheet: Q4 Sales
Column C (Revenue):
Total: $1,245,678
Average: $12,456
Rows: 100
Top 3 values:
1. $45,678 (Row 23)
2. $42,890 (Row 67)
3. $39,234 (Row 12)
[Show chart] [Export summary]
```
## Batch Operations
### Bulk Upload
```
User: Upload all files from my Downloads folder to Drive
Praxos: Found 24 files in Downloads (total: 156 MB)
Upload all to Google Drive?
User: Yes, to the "Uploads" folder
Praxos: Uploading 24 files...
✓ Complete (24/24)
Location: Google Drive > Uploads/
Total: 156 MB
```
### Bulk Download
```
User: Download all files from the "Project Alpha" folder
Praxos: "Project Alpha" contains 18 files (total: 89 MB)
[Sends ZIP archive: Project_Alpha.zip]
Size: 89 MB
```
### Bulk Share
```
User: Share all files in Reports folder with team@company.com
Praxos: Found 23 files in Reports/
Share all with team@company.com?
Permission: Can view
User: Yes
Praxos: ✓ Shared 23 files
Notification sent to team@company.com
```
## File Conversions
### PDF to Text
```
User: Convert report.pdf to text
Praxos: ✓ Converted "report.pdf"
[Sends text file: report.txt]
Original: 15 pages
Extracted: 3,456 words
```
### Image to PDF
```
User: Convert these 3 images to PDF
Praxos: [After receiving 3 images]
✓ Created "combined.pdf"
Pages: 3
Size: 2.1 MB
[Send file] [Upload to Drive]
```
## Integration Features
### Cross-Platform
```
User: Copy my Dropbox files to Google Drive
Praxos: Found 45 files in Dropbox
Copy all to Google Drive?
User: Yes
Praxos: Copying 45 files...
✓ Complete
Destination: Google Drive > From_Dropbox/
```
### Sync Status
```
User: Is my Drive synced?
Praxos: Google Drive sync status:
✓ All files synced
Last sync: 2 minutes ago
Pending uploads: 0
Pending downloads: 0
```
## Advanced Features
### Search by Content
```
User: Find documents containing "budget approval"
Praxos: Searching file contents...
Found 5 documents:
1. Q4_Planning.docx
"...awaiting budget approval for..."
2. Email_Summary.pdf
"...budget approval process complete..."
[Show all matches]
```
### Version History
```
User: Show previous versions of budget.xlsx
Praxos: Version history for "budget.xlsx":
Current (v4) - Today, 2:30 PM
v3 - Yesterday, 4:15 PM
v2 - Oct 8, 10:00 AM
v1 - Oct 5, 9:30 AM
[Restore version] [Compare versions]
```
### Duplicate Detection
```
User: Find duplicate files in my Drive
Praxos: Found 8 duplicate files:
• presentation.pptx (2 copies, 10 MB)
• report.pdf (3 copies, 6 MB)
• data.xlsx (2 copies, 2 MB)
Total wasted space: 18 MB
[Remove duplicates] [Review manually]
```
## Storage Management
### Check Usage
```
User: How much storage am I using?
Praxos: Google Drive storage:
Used: 8.3 GB / 15 GB (55%)
Available: 6.7 GB
Breakdown:
• Documents: 3.2 GB
• Photos: 2.8 GB
• Videos: 1.5 GB
• Other: 0.8 GB
[Manage storage] [Upgrade]
```
### Clean Up
```
User: Find large files I haven't used in 6 months
Praxos: Found 12 large old files:
• OldVideo.mp4 - 2.1 GB (8 months old)
• Backup.zip - 1.5 GB (1 year old)
• Presentation.pptx - 850 MB (7 months old)
Total: 6.2 GB can be freed
[Delete] [Archive] [Review]
```
## Troubleshooting
### Upload Failures
* Check file size limits (Google: 5TB, OneDrive: 250GB)
* Verify internet connection
* Check storage quota
* Verify file isn't corrupt
### Can't Find File
* Check spelling
* Verify correct account
* Check trash/deleted items
* Search by file type or date
### Permission Errors
* Verify file owner
* Check sharing permissions
* Re-authenticate integration
* Request access from owner
## Best Practices
* Use descriptive file names
* Organize with folders
* Regular cleanup of old files
* Use version history
* Share with appropriate permissions
* Enable file recovery
## Security
* Files encrypted in transit and at rest
* Per-user credential isolation
* Secure OAuth tokens
* Permission-based access
* Activity logging
## Next Steps
# Quickstart
Source: https://docs.mypraxos.com/guides/quickstart
Get up and running with Praxos in minutes
## Prerequisites
Before you begin, ensure you have:
* Python 3.11 or higher
* Docker and Docker Compose (for containerized deployment)
* Access to required API keys (see Configuration section)
## Local Development Setup
### 1. Clone the Repository
```bash theme={null}
git clone https://github.com/praxos/hetairos.git
cd hetairos
```
### 2. Install Dependencies
```bash theme={null}
pip install -r requirements.txt
```
### 3. Configure Environment Variables
Create a `.env` file in the root directory:
```bash theme={null}
# Core Configuration
ENVIRONMENT=development
# LLM Configuration (via Portkey)
PORTKEY_API_KEY=your_portkey_api_key
OPENAI_API_KEY=your_openai_api_key
GOOGLE_API_KEY=your_google_api_key
# Database
MONGODB_URI=mongodb://localhost:27017
DATABASE_NAME=hetairos
# Azure Services (if using)
AZURE_KEY_VAULT_URL=your_keyvault_url
AZURE_COSMOS_ENDPOINT=your_cosmos_endpoint
AZURE_SERVICE_BUS_NAMESPACE=your_service_bus
# Messaging Platform Tokens (configure as needed)
TELEGRAM_BOT_TOKEN=your_telegram_bot_token
DISCORD_BOT_TOKEN=your_discord_bot_token
SLACK_BOT_TOKEN=your_slack_bot_token
```
You don't need to configure all integrations at once. Start with the platforms you plan to use.
### 4. Install Playwright Browsers
For the AI-powered web browsing feature:
```bash theme={null}
playwright install
```
### 5. Start the Server
```bash theme={null}
python src/main.py
```
The API will be available at `http://localhost:8000`.
### 6. Start Background Workers
In a separate terminal:
```bash theme={null}
python run_workers_local.py
```
## Using Praxos
### Connect via Telegram
1. Create a bot using [@BotFather](https://t.me/botfather) on Telegram
2. Add your bot token to the `.env` file as `TELEGRAM_BOT_TOKEN`
3. Start a conversation with your bot
4. Send `/start` to initialize
### Connect via Discord
1. Create a Discord application at the [Discord Developer Portal](https://discord.com/developers/applications)
2. Create a bot and copy the token
3. Add the token to your `.env` file as `DISCORD_BOT_TOKEN`
4. Invite the bot to your server using OAuth2 URL generator
5. Send messages to interact with Praxos
### Connect via Slack
1. Create a Slack app at [api.slack.com](https://api.slack.com/apps)
2. Configure OAuth & Permissions with required scopes
3. Install the app to your workspace
4. Add the bot token to `.env` as `SLACK_BOT_TOKEN`
5. Invite the bot to channels using `/invite @YourBot`
## Next Steps
Learn about Praxos's architecture and design principles
Explore available integrations and how to configure them
Discover what Praxos can do for you
Deploy Praxos to production with Kubernetes
## Troubleshooting
### Server Won't Start
* Check that all required environment variables are set
* Verify MongoDB is running and accessible
* Check logs in the console for specific error messages
### Integration Not Working
* Verify API tokens are correctly configured
* Check that webhooks are properly set up (for platforms that require them)
* Review integration-specific documentation
### Browser Tool Failing
* Ensure Playwright browsers are installed: `playwright install`
* Check available memory (browser automation requires \~200-500MB)
* Verify the target website isn't blocking automation
For additional help, check the troubleshooting guide or open an issue on GitHub.
# Tools & Capabilities Overview
Source: https://docs.mypraxos.com/guides/tools-overview
Discover what Praxos can do for you
## Overview
Praxos comes equipped with a wide range of tools and capabilities to help you stay productive, organized, and informed.
## Tool Categories
Browse websites, search the web, and extract information
Schedule events, check availability, and manage your time
Send, read, and organize emails across platforms
Access, upload, and manage files in cloud storage
## Core Capabilities
### Communication Tools
**Send Messages**
* Send messages across platforms
* Cross-platform messaging
* Rich formatting support
* File attachments
**Intermediate Updates**
* Progress notifications during long operations
* Real-time status updates
* User feedback loops
### Information Retrieval
**Web Browsing**
* Simple HTML page reading
* AI-powered JavaScript-heavy site interaction
* Content extraction and summarization
* Multi-step navigation
**Search**
* Web search via Google
* Targeted information lookup
* Visual search with Google Lens
* Context-aware results
### Task & Schedule Management
**Calendar**
* Create and manage events
* Check availability
* Find meeting times
* Multi-calendar support
**Scheduling**
* Recurring task execution
* Time-zone aware scheduling
* Cron-like expressions
* One-time and periodic tasks
**Reminders**
* Set reminders for specific times
* Context-aware notifications
* Snooze and reschedule
### Data & File Management
**File Operations**
* Upload and download files
* File format conversion
* OCR for images
* Document parsing (PDF, Word, Excel)
**Database**
* Store user preferences
* Maintain conversation context
* User-specific data isolation
* Efficient querying
### Knowledge Management
**Notion**
* Create and update pages
* Database queries
* Content blocks
* Search workspace
**Note Taking**
* Quick notes
* Structured information capture
* Context linking
* Search and retrieval
### Project Management
**Trello**
* Board and card management
* Task tracking
* Team collaboration
* Progress monitoring
**Task Organization**
* Categorization
* Priority setting
* Due date tracking
* Status updates
## AI Capabilities
### Natural Language Understanding
Praxos understands:
* Complex, multi-step requests
* Context from conversation history
* Ambiguous or partial information
* Follow-up questions
### Intelligent Reasoning
* Break down complex tasks
* Multi-tool orchestration
* Error handling and recovery
* Adaptive responses
### Context Awareness
* Remembers conversation history
* User preferences and patterns
* Cross-integration context
* Time-zone awareness
## Tool Execution Pattern
```mermaid theme={null}
graph LR
A[User Request] --> B[Intent Analysis]
B --> C[Tool Selection]
C --> D[Tool Execution]
D --> E{Success?}
E -->|Yes| F[Format Response]
E -->|No| G[Error Handling]
G --> H[Retry or Alternative]
H --> D
F --> I[Send to User]
```
## Dynamic Tool Creation
Tools are created dynamically based on:
* User's active integrations
* Available credentials
* User permissions
* Context requirements
Example:
```python theme={null}
# User with Google Calendar connected
tools = [
search_web,
read_webpage,
create_calendar_event, # ✓ Available
search_calendar, # ✓ Available
send_message
]
# User without Google Calendar
tools = [
search_web,
read_webpage,
# Calendar tools not available
send_message
]
```
## Tool Descriptions
Each tool has clear descriptions for the AI:
```python theme={null}
@tool
async def create_calendar_event(
title: str,
start_time: datetime,
end_time: datetime,
attendees: Optional[List[str]] = None
):
"""
Creates a calendar event.
Args:
title: Event title
start_time: Event start (ISO format)
end_time: Event end (ISO format)
attendees: Email addresses of attendees
Returns:
Event details and confirmation
"""
```
## Error Handling
Robust error handling for:
* API failures
* Network issues
* Invalid inputs
* Permission errors
* Rate limiting
## Performance Features
### Caching
* User context cached in-memory
* Integration credentials cached
* Frequently accessed data
* Smart cache invalidation
### Async Operations
* All I/O operations async
* Concurrent tool execution where possible
* Non-blocking user interactions
### Retry Logic
* Automatic retries for transient failures
* Exponential backoff
* Circuit breaker pattern
* Graceful degradation
## Tool Permissions
### User-Level Control
Users can:
* Enable/disable specific tools
* Set usage limits
* Configure tool behavior
* Review tool activity
### Integration-Based
Tools automatically available when:
* Integration is configured
* Credentials are valid
* Permissions are granted
* Service is accessible
## Limitations & Quotas
### API Rate Limits
External services have limits:
* Google Calendar: 1M requests/day
* Microsoft Graph: 2K requests/min
* Notion: 3 requests/sec
* Trello: 100 requests/10sec
### Resource Constraints
* Message size limits (platform-specific)
* File size limits
* Processing time limits
* Memory constraints
### Feature Availability
Some features require:
* Specific integrations
* Premium accounts
* Admin permissions
* Geographic availability
## Custom Tools
Future capability for users to:
* Define custom tools
* Create workflows
* Build automations
* Share with community
## Monitoring & Analytics
Track tool usage:
* Execution frequency
* Success rates
* Execution time
* Error patterns
## Next Steps
Explore specific tool categories:
# Use Cases
Source: https://docs.mypraxos.com/guides/use-cases
Real-world examples of what Praxos can do for you
## Overview
Praxos excels at automating workflows, connecting different platforms, and helping you get things done faster. Here are some powerful real-world use cases.
## Cross-Platform Automation
### Email to WhatsApp Notifications
Automatically get notified on WhatsApp when you receive emails from specific people.
**Example:**
```
User: If I get an email from soheilsadalt@gmail.com,
send me a reminder on whatsapp.
Praxos: I have set up that trigger for you.
[Later, when email arrives...]
Praxos: You have received a new email from
soheilsadalt@gmail.com with the following content:
"hi thereeee"
This is your reminder, as you requested.
```
**Use Cases:**
* Get WhatsApp alerts for important client emails
* Notify team on Slack when you receive specific emails
* Cross-platform notification for time-sensitive messages
* VIP email monitoring
**How It Works:**
1. Praxos monitors your Gmail inbox
2. Watches for emails from specified addresses
3. Sends notification to your preferred platform
4. Includes email preview/content
### Other Automation Examples
**Calendar to Slack:**
```
"Post in #team channel 15 minutes before any meeting with clients"
```
**Task Management:**
```
"When I mark a Trello card as done, add it to my Notion completed tasks database"
```
**Email Filtering:**
```
"If I get an email with 'urgent' in subject, send me a Discord DM immediately"
```
## Visual Search & Shopping
### Image-to-Product Search
Send a photo of something you like, and Praxos finds where to buy it.
**Example:**
```
User: [Sends photo of Nike shoes]
what is this? can you find me amazon link to purchase this?
Praxos: You got it, braindaddy. Here is the link for the Nike AL8
on Amazon Brazil:
https://www.amazon.com.br/Tênis-feminino-Branco-prata...
Nike Tênis feminino Al8
O AL8 é a mistura perfeita de nostalgia (veja o
Swoosh bordado) e o conforto moderno que você ama...
[Shows product image and details]
```
**Use Cases:**
* Find products from photos
* Compare prices across retailers
* Identify clothing, shoes, accessories
* Discover similar products
* Shop from real-world inspiration
**Supported Platforms:**
* Amazon (all regions)
* eBay
* Shopping websites
* Brand websites
### Visual Recognition Capabilities
**Identify objects:**
```
User: [Sends photo of plant]
What plant is this?
Praxos: That's a Monstera Deliciosa (Swiss Cheese Plant)...
```
**Read text from images (OCR):**
```
User: [Sends photo of receipt]
Add these expenses to my spreadsheet
Praxos: Extracted from receipt:
- Coffee: $5.50
- Sandwich: $12.00
Total: $17.50
Added to your expense tracker ✓
```
**Analyze documents:**
```
User: [Sends photo of handwritten notes]
Convert this to text
Praxos: Here's the text from your notes:
[Converts handwriting to digital text]
```
## Web Research & Comparison
### Hotel & Travel Research
Get curated recommendations based on your specific criteria.
**Example:**
```
User: I need hotel results with good prices near San Jose,
Palo Alto, and San Mateo on November 2025. Look for
hotels near Stanford, Google campus, downtown San Jose,
Santana Row, and Palo Alto Park.
Praxos: Here are some of the options I found on the first
page of results:
📍 Hotels in Mountain View/Palo Alto Area:
• "Comfort Inn Palo Alto" - $158/night
Rating: 3.6/5 (1,400 reviews)
Link: [booking.com link]
• "The Zen Hotel Palo Alto" - $119/night
Rating: 4.5/5 (280 reviews)
Link: [booking.com link]
📍 Hotels Near Stanford:
• "Cardinal Hotel" - $287/night
Rating: 4.3/5 (500 reviews)
Link: [booking.com link]
📍 Hotels in San Jose (Downtown/Santana Row):
• "Hotel Montgomery" - $179/night
Rating: 4.0/5 (900 reviews)
Link: [booking.com link]
[... continues with more options ...]
```
**Benefits:**
* Multi-location search in one query
* Price comparison across sites
* Rating and review aggregation
* Direct booking links
* Location-based filtering
### Other Research Examples
**Product Comparison:**
```
User: Compare the top 5 wireless headphones under $200
Praxos: Here are the top 5 wireless headphones under $200:
1. Sony WH-1000XM4 - $178
• Active noise cancellation
• 30hr battery
• Rating: 4.7/5
2. Bose QuietComfort 45 - $199
[... detailed comparison ...]
```
**Restaurant Finder:**
```
User: Find Italian restaurants near me with outdoor seating,
open now, under $30 per person
Praxos: Found 8 Italian restaurants matching your criteria:
[Lists with ratings, prices, distance, links]
```
**Flight Research:**
```
User: Find the cheapest flights from SFO to NYC next month,
flexible dates, non-stop preferred
Praxos: Searching flights from SFO to NYC...
[Returns flight options with prices, times, airlines]
```
## Productivity Automation
### Meeting Preparation
```
User: I have a meeting with Acme Corp tomorrow. Prepare a brief.
Praxos: Here's your meeting brief for Acme Corp tomorrow:
📅 Meeting: Tomorrow at 2:00 PM
👥 Attendees: John Smith (CEO), Sarah Johnson (CTO)
📧 Recent Emails:
• Oct 5: Proposal discussion
• Oct 1: Initial contact
📁 Related Files:
• Acme_Proposal_v2.pdf (Google Drive)
• Meeting_Notes_Sept.docx
🔍 Company Info:
• Series B funded, $20M
• 50 employees
• Focus: Enterprise SaaS
[Set reminder for 30 min before meeting]
```
### Daily Briefing
```
User: Give me my daily briefing
Praxos: Good morning! Here's your briefing for Oct 10:
📅 Calendar (4 events):
• 9:00 AM - Daily Standup
• 11:00 AM - Client Call (Acme Corp)
• 2:00 PM - Sprint Planning
• 4:00 PM - 1-on-1 with Manager
📧 Priority Emails (3):
• Boss - Q4 Goals review needed
• Client - Contract signature required
• HR - Benefits enrollment deadline
✅ Tasks Due Today (2):
• Review pull request #234
• Submit expense report
🌤️ Weather: Sunny, 72°F
📰 News highlights:
[Relevant news based on interests]
```
### Email Summarization
```
User: Summarize all emails from this week about the Alpha project
Praxos: Summary of Alpha Project emails (Oct 7-10):
Key Updates:
• Phase 1 completed ahead of schedule
• Budget approved for Phase 2
• New team member joining next week
Action Items:
• Review architecture docs (by Oct 12)
• Schedule kickoff meeting for Phase 2
• Update stakeholders on timeline
Decisions Made:
• Using React for frontend
• AWS for hosting
• Sprint duration: 2 weeks
```
## Workflow Integrations
### Content Creation Workflow
```
User: Create a blog post workflow
Praxos: I'll help you set up a blog workflow. Here's what I can do:
1. Research: I'll gather info on your topic
2. Outline: Create structured outline
3. Draft: Write initial content
4. Save: Store in Google Docs or Notion
5. Schedule: Add to content calendar
6. Remind: Alert you for review
What topic should we start with?
```
### Job Application Tracker
```
User: Track my job applications in Trello
Praxos: ✓ Created job application tracker:
Lists:
• To Apply
• Applied - Waiting
• Phone Screen
• Interview
• Offer / Rejected
I'll help you:
• Add new applications
• Track deadlines
• Set interview reminders
• Log follow-ups
```
### Personal Finance
```
User: Track my expenses this month
Praxos: I'll help you track expenses. I can:
• Parse receipts (send photos)
• Categorize spending
• Update Google Sheets
• Weekly summaries
• Budget alerts
Current month:
• Food: $450
• Transport: $120
• Entertainment: $80
Total: $650
```
## Smart Assistance
### Context-Aware Responses
Praxos remembers your preferences and context:
```
User: Schedule the usual
Praxos: Scheduled "1-on-1 with Sarah" for next Tuesday at 2pm
(your regular weekly meeting time)
```
### Proactive Suggestions
```
Praxos: I notice you have a flight to NYC tomorrow at 8am.
Suggestions:
• Set alarm for 5:30am?
• Order Uber to airport at 6:00am?
• Check in for flight now?
• Download offline maps for NYC?
```
### Learning Patterns
```
User: Find me a good sushi place
Praxos: Based on your previous choices, here are highly-rated
sushi restaurants within 2 miles (your usual range):
• Sushi Roku - $$$ (you liked this last time)
• Blue Sushi - $$ (new, similar to your preferences)
[...]
```
## Advanced Use Cases
### Multi-Step Research
```
User: Research competitors for my SaaS product, compare their
pricing, and create a spreadsheet
Praxos: I'll research your competitors. What's your product category?
User: Project management software
Praxos: Researching project management SaaS competitors...
Found 10 major competitors:
1. Asana - Starting at $10.99/user/month
2. Monday.com - Starting at $8/user/month
[... detailed analysis ...]
✓ Created comparison spreadsheet in Google Sheets
✓ Added pricing tiers, features, ratings
✓ Included market positioning analysis
[Link to spreadsheet]
```
### Travel Planning
```
User: Plan a weekend trip to Seattle
Praxos: I'll help plan your Seattle weekend trip!
When are you thinking of going?
User: Next month, November 15-17
Praxos: Great! Planning your Seattle trip for Nov 15-17:
✈️ Flights:
• SFO → SEA: Nov 15, 8am - $180
• SEA → SFO: Nov 17, 6pm - $165
[Book flights?]
🏨 Hotels:
• Hotel Max - $220/night (downtown)
• Mediterranean Inn - $150/night (Queen Anne)
[Book hotel?]
🎯 Things to Do:
• Pike Place Market
• Space Needle
• Museum of Pop Culture
• Seattle Aquarium
🍽️ Restaurant Recommendations:
• Pike Place Chowder (must-try)
• Canlis (fine dining)
📅 Created trip itinerary in your calendar
✓ Added flight times
✓ Added check-in/check-out reminders
```
### Learning & Education
```
User: I want to learn Python. Create a study plan.
Praxos: ✓ Created your Python learning plan:
Week 1-2: Basics
• Variables, data types, operators
• Control flow (if/else, loops)
• Functions
Daily practice: 1 hour
Week 3-4: Intermediate
• Lists, dictionaries, sets
• File handling
• Error handling
[...]
✓ Added to Notion workspace
✓ Set daily study reminders (7pm)
✓ Created Trello board for practice projects
Resources:
• Python.org tutorial
• Recommended books: [links]
• Practice sites: [links]
```
## Tips for Effective Use
### Be Specific
❌ "Find hotels"
✅ "Find 4-star hotels in downtown Seattle under \$200/night with free parking"
### Combine Multiple Tasks
```
"Search for the top 5 Italian restaurants near me, check my calendar
for free time this week, and suggest 3 dinner reservation times"
```
### Set Up Automations
```
"Every Monday at 9am, give me a summary of last week's accomplishments
from my Trello boards and email it to my boss"
```
### Use Natural Language
You don't need special commands - just talk naturally:
* "Remind me to call mom tomorrow"
* "What's on my calendar?"
* "Find me a good laptop under \$1000"
## Need More Ideas?
Check out our integration-specific guides for more use cases:
# Web Browsing
Source: https://docs.mypraxos.com/guides/web-browsing
AI-powered web browsing and information extraction
## Overview
Praxos provides two levels of web browsing capabilities: simple HTML reading for static sites and AI-powered browsing for JavaScript-heavy dynamic sites.
## Simple Web Reading
### read\_webpage\_content
Fast, efficient reading of static HTML pages.
**Use Cases:**
* News articles
* Blog posts
* Documentation pages
* Simple product pages
* Any content-first website
**Example:**
```
User: What's on the Python documentation homepage?
Praxos: Let me check the Python docs...
[2-3 seconds later]
The Python documentation homepage features:
- Getting Started guide
- Tutorial for beginners
- Library Reference
- Language Reference
- Python Setup and Usage guides
```
**Characteristics:**
* Speed: 2-5 seconds
* Cost: Minimal (no LLM calls)
* JavaScript: Not supported
* Interaction: Read-only
## AI-Powered Browsing
### browse\_website\_with\_ai
Intelligent browser automation using Playwright and AI.
**Use Cases:**
* JavaScript-rendered content
* Dynamic web applications
* Form submissions
* Multi-step navigation
* Complex site interactions
* Content behind interactions
**Example:**
```
User: Search for "wireless headphones under $100" on Amazon
and tell me the top results
Praxos: I'm browsing Amazon now, this will take about 30 seconds...
[30-60 seconds later]
Top wireless headphones under $100 on Amazon:
1. Anker Soundcore Q20 - $59.99
- 40hr battery, active noise cancellation
- Rating: 4.5/5 (12,483 reviews)
2. JBL Tune 510BT - $29.95
- Lightweight, 40hr battery
- Rating: 4.4/5 (8,291 reviews)
3. Sony WH-CH510 - $38.00
- 35hr battery, quick charge
- Rating: 4.3/5 (15,673 reviews)
```
**Characteristics:**
* Speed: 30-60 seconds
* Cost: \~\$0.01-0.05 per task
* JavaScript: Full support
* Interaction: Clicks, forms, navigation
## How AI Browsing Works
```mermaid theme={null}
graph TB
A[User Request] --> B[Praxos sends
intermediate message]
B --> C[Launch Playwright
Browser]
C --> D[Navigate to URL]
D --> E[AI Analyzes Page]
E --> F{Task Complete?}
F -->|No| G[Execute Action]
G --> H[Wait for Response]
H --> E
F -->|Yes| I[Extract Information]
I --> J[Format Response]
J --> K[Send to User]
```
## User Experience Pattern
Praxos ALWAYS sends an intermediate message before starting AI browsing to set expectations.
**Flow:**
1. User makes request involving browsing
2. Praxos: "I'm browsing that website now, about 30 seconds..."
3. \[Browser automation happens]
4. Praxos: \[Final response with information]
This ensures users know the operation will take time.
## Capabilities
### Navigation
* **Load pages** - Go to any URL
* **Click links** - Follow links and buttons
* **Form submission** - Fill forms and submit
* **Scrolling** - Scroll to load more content
* **Back/Forward** - Navigate history
### Interaction
* **Input fields** - Type into text boxes
* **Dropdowns** - Select from menus
* **Checkboxes** - Toggle options
* **Buttons** - Click any clickable element
* **Hover** - Trigger hover effects
### Data Extraction
* **Text content** - Extract visible text
* **Structured data** - Parse tables, lists
* **Metadata** - Titles, descriptions, prices
* **Images** - Alt text and descriptions
* **Links** - Extract URLs
### Multi-Step Tasks
```
User: Go to product page, add to cart,
and tell me the total price
Praxos: I'll browse that site now, about 45 seconds...
[Steps executed:]
1. Navigate to product page
2. Click "Add to Cart"
3. Go to cart
4. Extract total price
Result: Total price with this item is $127.49
```
## Configuration
### Tool Parameters
```python theme={null}
browse_website_with_ai(
url: str, # Target URL
task: str, # Natural language task
max_steps: int = 10 # Maximum browser actions
)
```
### Environment Setup
```bash theme={null}
# Playwright installation required
playwright install
# Or in Docker (already included)
FROM mcr.microsoft.com/playwright/python:v1.55.0-noble
```
### Resource Requirements
* Memory: \~200-500MB per execution
* CPU: Moderate usage
* Network: Required
* Time: 30-60 seconds average
## Comparison
| Feature | read\_webpage\_content | browse\_website\_with\_ai |
| ----------------- | ---------------------- | ------------------------- |
| Speed | 2-5 seconds | 30-60 seconds |
| JavaScript | ❌ No | ✅ Yes |
| Forms/Interaction | ❌ No | ✅ Yes |
| Multi-page | ❌ No | ✅ Yes |
| Cost | Free | \~\$0.01-0.05 |
| User notification | Not needed | Required |
| Use case | Static sites | Dynamic sites |
## Best Practices
### When to Use Simple Reading
* Static content sites
* Speed is priority
* No interaction needed
* Content loads without JavaScript
### When to Use AI Browsing
* JavaScript-rendered content
* Need to interact with forms
* Multi-step navigation required
* Content behind clicks/scrolls
### Task Descriptions
Write clear, specific tasks:
**Good:**
```
"Search for 'laptop' and extract the top 5 results with prices"
"Fill the contact form with name 'John', email 'john@example.com', and submit"
"Navigate to pricing page and extract all plan details"
```
**Too Vague:**
```
"Get information from the site"
"Look around"
"Find stuff"
```
## Limitations
### Website Restrictions
Some sites block automation:
* CAPTCHAs
* Bot detection systems
* Rate limiting
* Cloudflare protection
### Performance
* Not suitable for real-time needs
* Resource intensive
* May timeout on very slow sites
### Accuracy
* AI may misinterpret complex layouts
* Depends on clear task descriptions
* May need multiple attempts
## Troubleshooting
### Browser Timeout
**Problem:** Task takes too long
**Solutions:**
* Increase `max_steps` parameter
* Simplify the task
* Try a more specific URL
* Check site isn't blocking automation
### Playwright Not Found
**Problem:** `playwright` executable not found
**Solution:**
```bash theme={null}
playwright install
```
### Memory Issues
**Problem:** Out of memory errors
**Solutions:**
* Increase pod/container memory
* Limit concurrent browsing tasks
* Use simple reading when possible
### Navigation Failures
**Problem:** Can't find elements or navigate
**Solutions:**
* Check URL is correct
* Verify site structure hasn't changed
* Try more specific task description
* Check site isn't behind login
## Advanced Usage
### Screenshots (Future)
Vision model integration for:
* Visual verification
* Layout understanding
* Image-based navigation
### Session Persistence (Future)
Maintain browser sessions:
* Stay logged in
* Persist cookies
* Continue from previous state
### Parallel Browsing (Future)
Multiple browser instances:
* Research across sites
* Price comparisons
* Data aggregation
## Security
### Privacy
* Each user gets isolated browser
* No session sharing
* Cookies cleared after task
* No tracking
### Safety
* No credential storage in browser
* HTTPS enforced where possible
* No arbitrary code execution
* Sandboxed environment
## Next Steps
# Welcome to Praxos
Source: https://docs.mypraxos.com/index
Your AI-powered personal assistant and second memory
## What is Praxos?
Praxos is your AI Second Brain Intelligence - an intelligent assistant built by Praxos Intelligence that acts as your personal companion and second memory. It seamlessly integrates with your favorite communication platforms and productivity tools to help you manage tasks, schedule events, process information, and stay organized.
Access Praxos directly in your browser at mypraxos.com
Learn about the web application features
Set up the backend and integrations
Explore real-world examples
## Key Features
Connect via Telegram, Discord, Slack, WhatsApp, and iMessage.
Integrate with Google Calendar, Gmail, Microsoft 365, Notion, and more.
Intelligent web browsing with Playwright for JavaScript-heavy sites.
Schedule tasks, set reminders, and manage your workflow efficiently.
## Real-World Use Cases
See what Praxos can do for you:
Email-to-WhatsApp notifications, multi-platform alerts
Find products from photos, image recognition
Hotel search, price comparison, detailed research
Explore comprehensive examples of automation, research, and productivity.
## Architecture
Praxos is built with modern technologies:
* **FastAPI** backend for high-performance API handling
* **LangGraph** for sophisticated agent orchestration
* **Playwright** for AI-powered web automation
* **Docker & Kubernetes** ready for scalable deployment
* Multiple **LLM providers** (OpenAI, Google Gemini) via Portkey
Learn more about how Praxos is architected.
## Popular Integrations
# Discord Integration
Source: https://docs.mypraxos.com/integrations/discord
Connect Praxos with Discord for community and team communication
## Overview
Discord integration allows Praxos to participate in your servers, channels, and direct messages.
## Features
* Server and channel messaging
* Direct message support
* Rich embeds and formatting
* File attachments
* Thread support
* Slash commands
* Role-based permissions
## Setup
### 1. Create Discord Application
1. Go to [Discord Developer Portal](https://discord.com/developers/applications)
2. Click "New Application"
3. Name your application (e.g., "Praxos")
4. Navigate to "Bot" section
5. Click "Add Bot"
6. Copy the bot token
### 2. Configure Bot Permissions
Required permissions:
* Read Messages/View Channels
* Send Messages
* Send Messages in Threads
* Embed Links
* Attach Files
* Read Message History
* Add Reactions
### 3. Configure Praxos
Add to your `.env` file:
```bash theme={null}
DISCORD_BOT_TOKEN=your_discord_bot_token
DISCORD_APPLICATION_ID=your_application_id
```
### 4. Invite Bot to Server
1. Go to OAuth2 > URL Generator in Developer Portal
2. Select scopes: `bot`, `applications.commands`
3. Select permissions from step 2
4. Copy generated URL
5. Open URL and select server to add bot
### 5. Start Using
* **Direct Messages**: Send DM to bot
* **Channel Messages**: Mention bot using `@Praxos`
* **Slash Commands**: Use `/ask` or other configured commands
## Bot Commands
| Command | Description |
| -------------------------- | --------------------------------- |
| `/ask [question]` | Ask Praxos a question |
| `/summarize` | Summarize recent channel messages |
| `/remind [time] [message]` | Set a reminder |
| `/help` | Show available commands |
## Advanced Features
### Slash Commands
Configure custom slash commands:
```python theme={null}
# Example slash command registration
/schedule [task] [time] - Schedule a task
/search [query] - Search across integrations
/notion [action] - Interact with Notion
```
### Embeds
Praxos sends rich embeds for better formatting:
```
┌─────────────────────────────┐
│ 📊 Task Summary │
├─────────────────────────────┤
│ Completed: 8 │
│ Pending: 3 │
│ Due Today: 2 │
└─────────────────────────────┘
```
### Thread Support
Praxos can create and respond in threads:
* Automatic thread creation for long conversations
* Context maintained within threads
* Clean channel organization
### Role-Based Access
Configure which roles can interact with Praxos:
* Admin-only commands
* Channel-specific permissions
* User-level restrictions
## Configuration
### Environment Variables
```bash theme={null}
# Required
DISCORD_BOT_TOKEN=your_bot_token
DISCORD_APPLICATION_ID=your_app_id
# Optional
DISCORD_COMMAND_PREFIX=!
DISCORD_MAX_MESSAGE_LENGTH=2000
DISCORD_ALLOWED_GUILDS=guild_id1,guild_id2
```
### Server Settings
Configure per-server:
* Active channels
* Command prefix
* Response behavior
* Notification preferences
## Troubleshooting
### Bot Appears Offline
* Check token is correct
* Verify intents are enabled in Developer Portal
* Check bot has proper permissions
### Commands Not Working
* Ensure bot has "Use Application Commands" permission
* Re-sync slash commands
* Check bot role hierarchy
### Missing Permissions
```bash theme={null}
# Check bot permissions
/permissions @Praxos
```
## Next Steps
# Google Suite Integration
Source: https://docs.mypraxos.com/integrations/google
Connect Praxos with Google Calendar, Gmail, Drive, and more
## Overview
Google Suite integration provides access to Google's productivity tools including Calendar, Gmail, Drive, and other services.
## Supported Services
* **Gmail** - Send, read, and manage emails
* **Google Calendar** - Schedule events, check availability
* **Google Drive** - Access and manage files
* **Google Search** - Web search capabilities
* **Google Lens** - Visual search and recognition
## Setup
### 1. Create Google Cloud Project
1. Go to [Google Cloud Console](https://console.cloud.google.com)
2. Create a new project
3. Enable required APIs:
* Gmail API
* Google Calendar API
* Google Drive API
### 2. Configure OAuth Consent Screen
1. Go to "OAuth consent screen"
2. Choose "External" user type
3. Fill in application details
4. Add scopes (see below)
### 3. Create OAuth Credentials
1. Go to "Credentials"
2. Click "Create Credentials" > "OAuth client ID"
3. Application type: "Web application"
4. Add authorized redirect URIs:
```
https://your-domain.com/auth/google/callback
```
5. Download credentials JSON
### 4. Configure Praxos
Add to `.env`:
```bash theme={null}
GOOGLE_CLIENT_ID=your-client-id
GOOGLE_CLIENT_SECRET=your-client-secret
GOOGLE_REDIRECT_URI=https://your-domain.com/auth/google/callback
```
## OAuth Scopes
Required scopes:
### Gmail
```
https://www.googleapis.com/auth/gmail.send
https://www.googleapis.com/auth/gmail.readonly
https://www.googleapis.com/auth/gmail.modify
```
### Calendar
```
https://www.googleapis.com/auth/calendar
https://www.googleapis.com/auth/calendar.events
```
### Drive
```
https://www.googleapis.com/auth/drive
https://www.googleapis.com/auth/drive.file
```
## User Authorization
Users must authorize Praxos to access their Google account:
1. User: "Connect my Google Calendar"
2. Praxos: Provides authorization URL
3. User clicks URL and grants permissions
4. Tokens stored securely for user
5. Praxos: "Successfully connected to Google Calendar"
## Features
### Gmail
**Send Emails**
```
User: Send an email to john@example.com about the meeting
Praxos: What would you like the subject and content to be?
User: Subject: Tomorrow's Meeting, Content: [...]
Praxos: Email sent successfully!
```
**Read Emails**
```
User: What are my unread emails?
Praxos: You have 5 unread emails:
1. John Doe - Re: Project Update
2. Jane Smith - Q4 Planning
[...]
```
**Search Emails**
```
User: Find emails from Sarah about "budget"
Praxos: Found 3 emails from Sarah containing "budget"...
```
### Google Calendar
**Schedule Events**
```
User: Schedule a meeting with the team tomorrow at 2pm
Praxos: I'll schedule "Team Meeting" for tomorrow at 2:00 PM.
Duration: 1 hour (default)
[Confirm] [Change Time] [Cancel]
```
**Check Schedule**
```
User: What's on my calendar today?
Praxos: Today's schedule:
• 9:00 AM - Daily Standup
• 11:00 AM - Client Call
• 2:00 PM - Team Meeting
• 4:00 PM - 1-on-1 with Manager
```
**Find Available Slots**
```
User: When am I free for a 30-minute meeting this week?
Praxos: Available slots this week:
• Today: 3:00 PM - 5:00 PM
• Tomorrow: 10:00 AM - 12:00 PM, 3:30 PM - 5:00 PM
• Wednesday: 9:00 AM - 11:00 AM
```
### Google Drive
**Search Files**
```
User: Find my Q4 report PDF
Praxos: Found "Q4_Financial_Report.pdf"
Last modified: Oct 5, 2024
[Open] [Share] [Download]
```
**Upload Files**
```
User: [Sends file] Save this to my Drive
Praxos: Saved "presentation.pptx" to Google Drive
Location: My Drive/Work/Presentations
[View in Drive]
```
**Share Files**
```
User: Share the Q4 report with team@company.com
Praxos: Shared "Q4_Financial_Report.pdf" with team@company.com
Access: Can view
```
## Configuration
### Environment Variables
```bash theme={null}
# OAuth Credentials
GOOGLE_CLIENT_ID=your-client-id
GOOGLE_CLIENT_SECRET=your-client-secret
GOOGLE_REDIRECT_URI=https://your-domain.com/auth/google/callback
# Optional
GOOGLE_API_KEY=your-api-key # For services without OAuth
```
### Token Management
* Tokens stored per user in database
* Automatic refresh when expired
* Secure encryption at rest
* Revocable by user
## Troubleshooting
### Authorization Fails
* Check redirect URI matches exactly
* Verify all required scopes are requested
* Ensure OAuth consent screen is published
### API Quota Exceeded
Google APIs have quotas:
* Calendar: 1M requests/day
* Gmail: 1B quota units/day
* Drive: 20K requests/100 seconds
**Solutions:**
* Implement caching
* Batch operations
* Request quota increase
### Token Refresh Issues
* Verify refresh token is valid
* Check token hasn't been revoked
* Ensure OAuth client hasn't changed
## Security Best Practices
* Use HTTPS for redirect URIs
* Store tokens encrypted
* Implement token rotation
* Monitor suspicious activity
* Provide token revocation
## Rate Limiting
Praxos implements:
* Exponential backoff
* Request queuing
* Per-user rate limiting
* Quota monitoring
## Next Steps
# Microsoft 365 Integration
Source: https://docs.mypraxos.com/integrations/microsoft
Connect Praxos with Outlook, Calendar, OneDrive, and Teams
## Overview
Microsoft 365 integration provides access to Outlook, Calendar, OneDrive, Teams, and other Microsoft services through Microsoft Graph API.
## Supported Services
* **Outlook Email** - Send, read, and manage emails
* **Calendar** - Schedule events and manage availability
* **OneDrive** - Access and manage files
* **Teams** - Channel and chat integration
* **Contacts** - Access and manage contacts
* **To Do** - Task management
## Setup
### 1. Register Application in Azure
1. Go to [Azure Portal](https://portal.azure.com)
2. Navigate to "Azure Active Directory" > "App registrations"
3. Click "New registration"
4. Enter application details:
* Name: "Praxos"
* Supported account types: Choose based on needs
* Redirect URI: `https://your-domain.com/auth/microsoft/callback`
### 2. Configure API Permissions
Add delegated permissions:
**Mail**
* `Mail.Read`
* `Mail.ReadWrite`
* `Mail.Send`
**Calendar**
* `Calendars.Read`
* `Calendars.ReadWrite`
**Files**
* `Files.Read.All`
* `Files.ReadWrite.All`
**Teams** (optional)
* `Team.ReadBasic.All`
* `Channel.ReadBasic.All`
* `ChatMessage.Send`
### 3. Create Client Secret
1. Go to "Certificates & secrets"
2. Click "New client secret"
3. Set expiration (recommended: 24 months)
4. Copy the secret value immediately
### 4. Configure Praxos
Add to `.env`:
```bash theme={null}
MICROSOFT_CLIENT_ID=your-application-id
MICROSOFT_CLIENT_SECRET=your-client-secret
MICROSOFT_TENANT_ID=your-tenant-id
MICROSOFT_REDIRECT_URI=https://your-domain.com/auth/microsoft/callback
```
## User Authorization
OAuth flow for user authorization:
1. User requests Microsoft integration
2. Praxos provides authorization URL
3. User signs in with Microsoft account
4. Grants requested permissions
5. Tokens stored securely
6. Integration complete
## Features
### Outlook Email
**Send Emails**
```
User: Send an email to jane@company.com
Praxos: What should the subject and message be?
User: Subject: Team Update, Message: [...]
Praxos: ✓ Email sent to jane@company.com
```
**Read Emails**
```
User: Show my recent emails
Praxos: Recent emails:
1. Sarah - Project Status Update (10 min ago)
2. Mike - Meeting Notes (1 hour ago)
3. Team - Weekly Newsletter (2 hours ago)
```
**Search and Filter**
```
User: Find emails from last week about "budget"
Praxos: Found 4 emails about "budget" from last week...
```
### Calendar
**Schedule Meetings**
```
User: Schedule a 1-hour meeting with john@company.com tomorrow at 3pm
Praxos: Meeting scheduled:
Title: Meeting with John
Time: Tomorrow, 3:00 PM - 4:00 PM
Attendee: john@company.com
[View in Outlook]
```
**Check Schedule**
```
User: What meetings do I have today?
Praxos: Today's meetings:
• 10:00 AM - Team Sync (30 min)
• 2:00 PM - Client Review (1 hour)
• 4:00 PM - Planning Session (45 min)
```
**Find Meeting Times**
```
User: When are all three of us free for 30 minutes this week?
Praxos: Checking availability...
All free:
• Wed 2:00 PM - 3:00 PM
• Thu 10:30 AM - 11:30 AM
• Fri 3:00 PM - 4:00 PM
```
### OneDrive
**File Access**
```
User: Get my presentation from OneDrive
Praxos: Found "Q3_Presentation.pptx" in OneDrive
Last modified: 2 days ago
[Open] [Download] [Share]
```
**Upload Files**
```
User: [Sends file] Upload to my OneDrive
Praxos: Uploaded "report.docx" to OneDrive
Location: Documents/Reports/
[View in OneDrive]
```
**Share Files**
```
User: Share this file with the marketing team
Praxos: Created share link for "campaign_ideas.xlsx"
Access: Team can edit
Link: https://1drv.ms/x/s!Abc...
```
### Teams Integration
**Send Channel Messages**
```
User: Post in #general that the deployment is complete
Praxos: Posted to #general in Engineering team:
"✓ Deployment complete. All systems operational."
```
## Configuration
### Environment Variables
```bash theme={null}
# Required
MICROSOFT_CLIENT_ID=your-app-id
MICROSOFT_CLIENT_SECRET=your-secret
MICROSOFT_TENANT_ID=your-tenant-id
# Optional
MICROSOFT_REDIRECT_URI=https://your-domain.com/auth/microsoft/callback
MICROSOFT_AUTHORITY=https://login.microsoftonline.com
MICROSOFT_SCOPES=Mail.ReadWrite,Calendars.ReadWrite,Files.ReadWrite.All
```
### Graph API Settings
```python theme={null}
# Default settings
GRAPH_API_ENDPOINT = "https://graph.microsoft.com/v1.0"
MAX_RESULTS_PER_PAGE = 50
REQUEST_TIMEOUT = 30 # seconds
```
## Advanced Features
### Batch Requests
For efficiency, batch multiple requests:
```python theme={null}
# Example: Get calendar + emails + files in one request
batch_response = await graph.batch([
get_calendar_events(),
get_recent_emails(),
get_recent_files()
])
```
### Delta Queries
Track changes efficiently:
```python theme={null}
# Only get changes since last sync
delta_emails = await graph.get_delta('messages', last_delta_token)
```
### Webhooks
Real-time notifications for:
* New emails
* Calendar changes
* File updates
## Troubleshooting
### Authentication Issues
**Invalid Client**
* Verify Client ID and Secret
* Check Application ID in Azure Portal
* Ensure secret hasn't expired
**Insufficient Permissions**
* Check required API permissions granted
* Admin consent may be required
* Verify user has necessary licenses
### API Errors
**403 Forbidden**
* User lacks permissions
* Application lacks API permissions
* Tenant admin hasn't consented
**429 Too Many Requests**
* Rate limit exceeded
* Implement backoff strategy
* Review request patterns
**5xx Server Errors**
* Microsoft service issues
* Retry with exponential backoff
* Check [Microsoft Service Health](https://status.office.com)
## Rate Limits
Microsoft Graph throttling limits:
| Resource | Limit |
| -------- | ------------------- |
| Mail | 10K requests/10 min |
| Calendar | 10K requests/10 min |
| Files | 10K requests/10 min |
| Batch | 4 requests/second |
Praxos automatically handles throttling with retry logic and exponential backoff.
## Security
### Token Security
* Tokens encrypted at rest
* Automatic token refresh
* Secure credential storage
* Per-user isolation
### Conditional Access
Support for:
* Multi-factor authentication
* Conditional Access policies
* Device compliance requirements
### Compliance
* GDPR compliant
* SOC 2 considerations
* Data residency options
* Audit logging
## Best Practices
* Use batch requests when possible
* Implement delta queries for sync
* Cache frequently accessed data
* Monitor API usage and throttling
* Use webhooks for real-time updates
## Next Steps
# Notion Integration
Source: https://docs.mypraxos.com/integrations/notion
Connect Praxos with Notion for knowledge management
## Overview
Notion integration allows Praxos to read, create, and update pages and databases in your Notion workspace.
## Features
* Create and update pages
* Query databases
* Add content blocks
* Search across workspace
* Create database entries
* Update properties
## Setup
### 1. Create Notion Integration
1. Go to [Notion Integrations](https://www.notion.so/my-integrations)
2. Click "New integration"
3. Name: "Praxos"
4. Select associated workspace
5. Copy the Internal Integration Token
### 2. Configure Capabilities
Select capabilities:
* ✓ Read content
* ✓ Update content
* ✓ Insert content
### 3. Share Pages with Integration
For each page/database Praxos should access:
1. Open the page in Notion
2. Click "..." menu → "Add connections"
3. Select "Praxos" integration
### 4. Configure Praxos
Add to `.env`:
```bash theme={null}
NOTION_API_KEY=secret_xxx...
```
## Usage Examples
### Create Page
```
User: Create a Notion page called "Project Ideas"
Praxos: Created page "Project Ideas" in your Notion workspace.
[Open in Notion]
User: Add a bullet list of 3 project ideas to that page
Praxos: ✓ Added 3 bullet points to "Project Ideas"
```
### Query Database
```
User: Show me incomplete tasks from my Notion task database
Praxos: Found 5 incomplete tasks:
1. Review pull request #234
2. Update documentation
3. Schedule team meeting
4. Prepare presentation
5. Send follow-up emails
```
### Update Page
```
User: Add today's meeting notes to the "Daily Notes" page
Praxos: What were the key points from today's meeting?
User: [Provides notes]
Praxos: ✓ Added meeting notes to "Daily Notes"
Timestamp: Oct 10, 2024 2:30 PM
```
### Search
```
User: Find Notion pages about "Q4 planning"
Praxos: Found 3 pages:
1. Q4 Planning Overview
2. Q4 Marketing Strategy
3. Q4 Budget Allocation
[Show details] [Open in Notion]
```
## Database Operations
### Create Entry
```
User: Add a task to my task database: "Review code" due tomorrow
Praxos: ✓ Created task in database
Name: Review code
Status: To Do
Due: Tomorrow (Oct 11, 2024)
```
### Update Properties
```
User: Mark the "Review code" task as complete
Praxos: ✓ Updated task status to "Complete"
```
### Filter and Query
```
User: Show all high-priority tasks due this week
Praxos: High-priority tasks this week:
1. Client presentation (Due: Oct 12)
2. Budget approval (Due: Oct 13)
3. Team retrospective (Due: Oct 15)
```
## Content Blocks
Praxos can create various block types:
* **Paragraphs** - Text content
* **Headings** - H1, H2, H3
* **Lists** - Bulleted and numbered
* **To-do Lists** - Checkable items
* **Code Blocks** - With syntax highlighting
* **Quotes** - Block quotes
* **Callouts** - Info, warning, error boxes
* **Dividers** - Horizontal rules
* **Tables** - Data tables
Example:
```
User: Create a page with a heading "Weekly Goals",
a divider, and a to-do list with 3 items
Praxos: ✓ Created page with requested structure
```
## Configuration
### Environment Variables
```bash theme={null}
# Required
NOTION_API_KEY=secret_xxx...
# Optional
NOTION_VERSION=2022-06-28 # API version
NOTION_DEFAULT_PAGE_SIZE=100
```
### Workspace Settings
* Configure default database
* Set default page parent
* Define page templates
## Troubleshooting
### Integration Can't Access Page
**Solution:**
1. Open the page in Notion
2. Click "..." → "Add connections"
3. Select your integration
### API Rate Limit
Notion limits:
* 3 requests per second per integration
* Averaged over 60 seconds
**Praxos handles this automatically with:**
* Request queuing
* Rate limiting
* Automatic retries
### Invalid Token
* Verify token is correct
* Check token hasn't been revoked
* Ensure integration still exists
## Best Practices
* Share only necessary pages with integration
* Use descriptive page titles
* Structure databases consistently
* Leverage templates for consistency
* Regular cleanup of unused pages
## Limitations
Current Notion API limitations:
* No file uploads (coming soon)
* Limited block types (most common supported)
* No comments API
* No user mentions in content
## Security
* Tokens encrypted at rest
* Per-user token isolation
* Granular page-level permissions
* Revocable access
## Next Steps
# Integrations Overview
Source: https://docs.mypraxos.com/integrations/overview
Connect Praxos with your favorite platforms and services
## Available Integrations
Praxos supports a wide range of integrations across messaging platforms, productivity tools, and cloud services.
## Messaging Platforms
Connect Praxos to your preferred communication channels:
Fast, secure messaging with rich features
Community and team communication
Workspace collaboration and productivity
Popular mobile messaging platform
## Productivity Tools
Enhance your workflow with productivity integrations:
Calendar, Gmail, Drive, and more
Outlook, Calendar, OneDrive, Teams
Knowledge management and notes
Project management and task tracking
## Cloud Storage
Access and manage your files:
* **Google Drive** - Access, search, and manage files
* **Dropbox** - File storage and sharing
* **OneDrive** - Microsoft cloud storage
## Configuration Basics
### Authentication Flow
Most integrations follow this pattern:
1. **Obtain Credentials**
* API keys, tokens, or OAuth credentials
* From the service's developer portal
2. **Configure Environment**
```bash theme={null}
# Add to .env file
SERVICE_API_KEY=your_api_key
SERVICE_CLIENT_ID=your_client_id
SERVICE_CLIENT_SECRET=your_client_secret
```
3. **User Authorization**
* OAuth flow for user-specific access
* Credentials stored securely per user
4. **Test Connection**
* Verify integration is working
* Check logs for any errors
### OAuth Integrations
For OAuth-based integrations (Google, Microsoft, Notion):
```python theme={null}
# Example OAuth flow
1. User requests integration
2. Praxos provides authorization URL
3. User grants permissions
4. Praxos receives callback with tokens
5. Tokens stored in user's secure context
```
### API Key Integrations
For API key-based integrations (Telegram, Discord, Slack):
```bash theme={null}
# Simply add to environment
TELEGRAM_BOT_TOKEN=123456:ABC-DEF...
DISCORD_BOT_TOKEN=MTk4...
SLACK_BOT_TOKEN=xoxb-...
```
## Integration Features
### Real-time Notifications
* Webhook support for instant updates
* Event-driven architecture
* Configurable notification preferences
### Bidirectional Sync
* Read and write capabilities
* Automatic sync of changes
* Conflict resolution
### Smart Context Awareness
* Integration-aware AI responses
* Cross-platform context sharing
* Unified conversation history
## Security & Privacy
### Data Protection
* Credentials encrypted at rest
* User-level isolation
* No cross-user data access
### Permissions
* Granular permission scopes
* User-controlled access
* Easy revocation
### Compliance
* GDPR compliant
* SOC 2 considerations
* Data residency options
## Rate Limits
Each integration has specific rate limits:
| Integration | Rate Limit | Notes |
| --------------- | ----------- | -------------- |
| Telegram | 30 msg/sec | Per bot |
| Discord | 50 req/sec | Per bot |
| Slack | \~1 req/sec | Per workspace |
| Google APIs | Varies | Per user quota |
| Microsoft Graph | \~2000/min | Per app |
Praxos automatically handles rate limiting with exponential backoff and queuing.
## Troubleshooting
### Common Issues
**Authentication Failures**
* Verify API keys/tokens are correct
* Check token hasn't expired
* Ensure proper scopes/permissions
**Missing Features**
* Confirm integration is fully configured
* Check required permissions are granted
* Review integration-specific docs
**Performance Issues**
* Monitor rate limits
* Check network connectivity
* Review logs for errors
## Next Steps
Choose an integration to get started:
# Slack Integration
Source: https://docs.mypraxos.com/integrations/slack
Connect Praxos with Slack for workspace collaboration
## Overview
Slack integration brings Praxos into your workspace for seamless team collaboration.
## Features
* Channel and direct messaging
* Slash commands
* Interactive components (buttons, menus)
* File sharing
* Thread replies
* Rich text formatting
* Event subscriptions
## Setup
### 1. Create Slack App
1. Go to [api.slack.com/apps](https://api.slack.com/apps)
2. Click "Create New App"
3. Choose "From scratch"
4. Name your app and select workspace
### 2. Configure OAuth & Permissions
Add these bot token scopes:
* `chat:write` - Send messages
* `chat:write.public` - Send to channels without joining
* `channels:history` - View channel messages
* `channels:read` - View channels
* `groups:history` - View private channel messages
* `im:history` - View DM history
* `im:write` - Send DMs
* `users:read` - View users
* `files:write` - Upload files
* `commands` - Create slash commands
### 3. Enable Events
Subscribe to bot events:
* `message.channels`
* `message.groups`
* `message.im`
* `app_mention`
Set Request URL: `https://your-domain.com/slack/events`
### 4. Create Slash Commands
Add commands at "Slash Commands" section:
* `/ask` - Ask Praxos a question
* `/schedule` - Schedule a task
* `/summarize` - Summarize conversation
### 5. Install to Workspace
1. Go to "Install App"
2. Click "Install to Workspace"
3. Authorize the app
4. Copy the Bot User OAuth Token
### 6. Configure Praxos
Add to `.env`:
```bash theme={null}
SLACK_BOT_TOKEN=xoxb-your-bot-token
SLACK_SIGNING_SECRET=your-signing-secret
SLACK_APP_TOKEN=xapp-your-app-token # For Socket Mode
```
## Usage
### In Channels
```
@Praxos what's on my calendar today?
```
### Direct Messages
```
Send "Hello" to Praxos DM
```
### Slash Commands
```
/ask What are my pending tasks?
/schedule Team meeting tomorrow at 2pm
/summarize #project-alpha
```
## Interactive Features
### Action Buttons
```
Task: Review Q4 Report
[✓ Complete] [📝 Add Note] [⏰ Snooze]
```
### Select Menus
```
Choose a project:
[Dropdown: Project Alpha, Project Beta, Project Gamma]
```
### Modal Dialogs
For complex interactions:
* Form submissions
* Multi-step workflows
* Rich data input
## Configuration
### Environment Variables
```bash theme={null}
# Required
SLACK_BOT_TOKEN=xoxb-...
SLACK_SIGNING_SECRET=...
# Optional (for Socket Mode)
SLACK_APP_TOKEN=xapp-...
SLACK_SOCKET_MODE=true
```
### Workspace Settings
Configure per workspace:
* Default channels
* Notification preferences
* User permissions
* Rate limit handling
## Security
### Request Verification
Praxos verifies all Slack requests:
* Signing secret validation
* Timestamp verification
* Replay attack prevention
### OAuth Flow
For multi-workspace deployments:
* OAuth installation flow
* Token management
* Workspace isolation
## Troubleshooting
### Messages Not Sending
* Verify bot is in channel
* Check token permissions
* Review rate limits
### Events Not Received
* Confirm event subscriptions
* Check webhook URL is accessible
* Verify SSL certificate
### Slash Commands Failing
* Check command is registered
* Verify Request URL is correct
* Review command permissions
## Rate Limits
Slack rate limits:
* Tier 1: 1 request per second
* Tier 2: 20+ requests per minute
* Tier 3: 50+ requests per minute
* Tier 4: 100+ requests per minute
Praxos automatically handles rate limiting with queuing and retry logic.
## Best Practices
* Use threads for long conversations
* Leverage blocks for rich formatting
* Implement graceful error handling
* Cache frequently accessed data
* Monitor API usage
## Next Steps
# Telegram Integration
Source: https://docs.mypraxos.com/integrations/telegram
Connect Praxos with Telegram for fast, secure messaging
## Overview
Telegram is one of the most popular platforms for Praxos, offering rich features, speed, and security.
## Features
* Text messaging
* Voice messages
* File sharing (documents, images, videos)
* Inline keyboards for interactive commands
* Real-time responses
* Group chat support
## Setup
### 1. Create a Telegram Bot
1. Open Telegram and search for [@BotFather](https://t.me/botfather)
2. Send `/newbot` command
3. Follow prompts to name your bot
4. Copy the bot token provided
### 2. Configure Praxos
Add the token to your `.env` file:
```bash theme={null}
TELEGRAM_BOT_TOKEN=1234567890:ABCdefGHIjklMNOpqrsTUVwxyz
```
### 3. Set Webhook (Production)
For production deployments, configure a webhook:
```bash theme={null}
curl -X POST "https://api.telegram.org/bot/setWebhook" \
-H "Content-Type: application/json" \
-d '{"url": "https://your-domain.com/telegram/webhook"}'
```
For local development, Praxos uses polling mode automatically.
### 4. Start Conversation
1. Find your bot in Telegram (search for the username you created)
2. Send `/start` to initialize
3. Begin chatting with Praxos
## Bot Commands
Built-in Telegram commands:
| Command | Description |
| ----------- | --------------------------------------- |
| `/start` | Initialize bot and show welcome message |
| `/help` | Display available commands |
| `/settings` | Configure preferences |
| `/history` | View conversation history |
| `/clear` | Clear conversation context |
## Advanced Features
### Group Chats
Add Praxos to group chats:
1. Add bot to group as member
2. Grant admin permissions (optional, for better functionality)
3. Mention bot using `@YourBotName` to interact
4. Configure group-specific settings
### Inline Keyboards
Praxos can send interactive buttons:
```
Would you like to schedule this?
[Yes, 9 AM] [Yes, 2 PM] [No, thanks]
```
### File Handling
Send files to Praxos:
* **Documents** - PDFs, Word docs, text files
* **Images** - JPG, PNG (with OCR support)
* **Voice Messages** - Audio transcription
* **Videos** - Metadata extraction
### Rich Formatting
Praxos supports Telegram's formatting:
* **Bold**, *italic*, `code`
* Links and mentions
* Code blocks with syntax highlighting
## Configuration Options
### Environment Variables
```bash theme={null}
# Required
TELEGRAM_BOT_TOKEN=your_bot_token
# Optional
TELEGRAM_WEBHOOK_URL=https://your-domain.com/telegram/webhook
TELEGRAM_MAX_MESSAGE_LENGTH=4096
TELEGRAM_PARSE_MODE=Markdown # or HTML
```
### User Preferences
Users can configure:
* Response length preference
* Notification settings
* Default timezone
* Language preference
## Security
### Bot Token Security
Never share your bot token publicly. Treat it like a password.
* Store token in environment variables
* Use Azure Key Vault in production
* Rotate tokens if compromised
### User Privacy
* All conversations are private by default
* User data is isolated per user
* Praxos never shares messages with other users
### Rate Limiting
Telegram's limits:
* 30 messages per second per bot
* 20 messages per minute per chat
* Praxos automatically queues and throttles
## Troubleshooting
### Bot Not Responding
**Check Configuration**
```bash theme={null}
# Verify token is set
echo $TELEGRAM_BOT_TOKEN
# Test token validity
curl "https://api.telegram.org/bot/getMe"
```
**Check Logs**
```bash theme={null}
# Local development
tail -f logs/hetairos.log | grep telegram
# Kubernetes
kubectl logs -f deployment/hetairos | grep telegram
```
### Webhook Issues
**Verify Webhook Status**
```bash theme={null}
curl "https://api.telegram.org/bot/getWebhookInfo"
```
**Common Problems**
* SSL certificate issues (webhook requires HTTPS)
* Firewall blocking incoming requests
* Incorrect webhook URL
**Delete Webhook (for local dev)**
```bash theme={null}
curl -X POST "https://api.telegram.org/bot/deleteWebhook"
```
### Message Formatting Errors
* Use `parse_mode=Markdown` for Markdown formatting
* Escape special characters: `_`, `*`, `[`, `]`, `(`, `)`, `~`, `` ` ``, `>`, `#`, `+`, `-`, `=`, `|`, `{`, `}`, `.`, `!`
* Or use HTML mode with proper tags
## Best Practices
### User Experience
* **Quick Responses** - Send typing indicators for long operations
* **Clear Messages** - Format responses clearly with proper structure
* **Interactive Elements** - Use inline keyboards for common actions
* **File Support** - Accept multiple file types
### Performance
* **Async Operations** - All Telegram API calls are async
* **Connection Pooling** - Reuse HTTP connections
* **Retry Logic** - Automatic retries for transient failures
* **Caching** - Cache user context to reduce database calls
### Monitoring
Track key metrics:
* Message processing time
* Error rates
* Active users
* API call volumes
## Example Interactions
### Simple Query
```
User: What's the weather like?
Praxos: Let me check the weather for you...
Praxos: Current weather in San Francisco:
🌤️ Partly cloudy, 68°F
Humidity: 65%
Wind: 8 mph NW
```
### Task Creation
```
User: Remind me to call John tomorrow at 2pm
Praxos: I'll remind you tomorrow at 2:00 PM to call John.
[View Reminders] [Edit] [Cancel]
```
### File Processing
```
User: [Sends PDF document]
Praxos: Received "Q4_Report.pdf" (2.3 MB)
Processing document...
Summary:
- 45 pages
- Q4 revenue: $2.3M
- Key metrics improved 23% YoY
[Full Summary] [Ask Questions] [Save to Notion]
```
## Next Steps
Explore what Praxos can do
Connect additional services
# Trello Integration
Source: https://docs.mypraxos.com/integrations/trello
Connect Praxos with Trello for project management
## Overview
Trello integration enables Praxos to manage boards, lists, and cards in your Trello workspace.
## Features
* Create and update boards
* Manage lists
* Create, move, and update cards
* Add comments and attachments
* Manage labels and due dates
* Add members to cards
* Checklist management
## Setup
### 1. Get API Credentials
1. Go to [Trello Power-Ups Admin Portal](https://trello.com/power-ups/admin)
2. Click "New" to create a new Power-Up
3. Note your API Key
### 2. Generate Token
1. Visit: `https://trello.com/1/authorize?expiration=never&name=Praxos&scope=read,write&response_type=token&key=YOUR_API_KEY`
2. Click "Allow"
3. Copy the token
### 3. Configure Praxos
Add to `.env`:
```bash theme={null}
TRELLO_API_KEY=your_api_key
TRELLO_TOKEN=your_token
```
## Usage Examples
### Board Management
**List Boards**
```
User: Show my Trello boards
Praxos: Your Trello boards:
1. Product Roadmap
2. Marketing Campaign
3. Personal Tasks
4. Team Goals Q4
```
**Create Board**
```
User: Create a Trello board called "New Project"
Praxos: ✓ Created board "New Project"
Default lists: To Do, In Progress, Done
[Open in Trello]
```
### Card Operations
**Create Card**
```
User: Add a card "Design mockups" to my Product Roadmap board
Praxos: ✓ Created card in "Product Roadmap"
List: To Do
[View Card] [Add details]
```
**Update Card**
```
User: Move "Design mockups" to In Progress
Praxos: ✓ Moved card to "In Progress" list
```
**Add Details**
```
User: Add a due date of next Friday to the Design mockups card
Praxos: ✓ Updated card:
Due date: Oct 15, 2024
Reminder: 24 hours before
```
### Comments and Activity
**Add Comment**
```
User: Comment on the Design mockups card: "Great progress!"
Praxos: ✓ Added comment to card
Author: You
Time: Just now
```
**View Activity**
```
User: What's the latest activity on the Product Roadmap board?
Praxos: Recent activity:
• Sarah moved "API Integration" to Done (5 min ago)
• Mike added checklist to "Testing" (1 hour ago)
• You created "Design mockups" (2 hours ago)
```
### Checklists
**Create Checklist**
```
User: Add a checklist to Design mockups card with 3 items:
- Research competitors
- Create wireframes
- Get feedback
Praxos: ✓ Created checklist "Tasks" with 3 items
Progress: 0/3 complete
```
**Update Checklist**
```
User: Mark "Research competitors" as complete
Praxos: ✓ Checked off item
Progress: 1/3 complete (33%)
```
### Labels
**Add Label**
```
User: Add "High Priority" label to Design mockups
Praxos: ✓ Added label "High Priority" (Red)
```
**Filter by Label**
```
User: Show all high priority cards in Product Roadmap
Praxos: High priority cards:
1. Design mockups (To Do)
2. User testing (In Progress)
3. Launch preparation (To Do)
```
## Configuration
### Environment Variables
```bash theme={null}
# Required
TRELLO_API_KEY=your_api_key
TRELLO_TOKEN=your_token
# Optional
TRELLO_DEFAULT_BOARD=board_id
TRELLO_WEBHOOK_CALLBACK=https://your-domain.com/trello/webhook
```
### Board Templates
Configure default board structure:
```python theme={null}
DEFAULT_LISTS = ["To Do", "In Progress", "Review", "Done"]
DEFAULT_LABELS = ["High Priority", "Low Priority", "Bug", "Feature"]
```
## Advanced Features
### Webhooks
Real-time notifications for:
* Card created/updated/moved
* Comments added
* Checklist items completed
* Members added/removed
Setup webhook:
```bash theme={null}
POST https://api.trello.com/1/tokens/{token}/webhooks/
{
"callbackURL": "https://your-domain.com/trello/webhook",
"idModel": "board_id"
}
```
### Bulk Operations
```
User: Move all cards in "To Do" list that are due today to "In Progress"
Praxos: Moving 3 cards...
✓ Moved "Design mockups"
✓ Moved "Write documentation"
✓ Moved "Code review"
```
### Card Templates
Create cards from templates:
```
User: Create a bug report card for "Login not working"
Praxos: ✓ Created bug report card:
Title: [BUG] Login not working
Checklist:
- Reproduce issue
- Identify root cause
- Create fix
- Test thoroughly
- Deploy
Labels: Bug, High Priority
```
## Trello Power-Ups
Enhance with Power-Ups:
* Calendar view
* Custom fields
* Card aging
* Voting
* Time tracking
## Troubleshooting
### Authentication Issues
**Invalid Token**
* Token may have expired (if not set to "never")
* Regenerate token
* Update `.env` file
**Insufficient Permissions**
* Verify token has read/write scope
* Check API key is valid
* Ensure user has board access
### Rate Limits
Trello rate limits:
* 100 requests per 10 seconds per token
* 300 requests per 10 seconds per API key
Praxos implements request queuing and automatic retry with backoff.
### Board Not Found
* Verify board ID is correct
* Check user has access to board
* Board may have been deleted or archived
## Best Practices
* Use clear, descriptive card titles
* Leverage labels for categorization
* Set due dates for time-sensitive tasks
* Use checklists to break down complex tasks
* Archive completed cards regularly
* Maintain consistent board structure
## Security
* API keys and tokens encrypted
* Per-user credential isolation
* Secure webhook validation
* Regular token rotation recommended
## Integration with Other Tools
Combine Trello with other integrations:
```
User: Create a Trello card for every email from boss@company.com
Praxos: ✓ Created automation:
New emails from boss@company.com →
New cards in "Boss Requests" list
```
```
User: When I mark a Trello card as done,
add it to my Notion "Completed Tasks" database
Praxos: ✓ Created automation:
Trello card moved to Done →
Entry added to Notion database
```
## Next Steps
# Chat Interface
Source: https://docs.mypraxos.com/webapp/chat-interface
Master the Praxos conversation interface
## Overview
The chat interface is where you interact with your AI assistant. It's designed for natural, efficient communication with support for text, files, images, and more.
## Interface Layout
### Chat Window
The main chat area includes:
**Message Area**
* Your messages (right-aligned)
* AI responses (left-aligned)
* Timestamps
* Status indicators
**Input Box**
* Text input field
* File attachment button
* Voice input button (if available)
* Send button
* Formatting options
**Sidebar** (optional, toggle with button)
* Conversation list
* Search conversations
* Filters and tags
## Starting a Conversation
### New Chat
Create a new conversation:
1. Click **New Chat** button (or `Ctrl/Cmd + N`)
2. Start typing your message
3. Press Enter or click Send
### Continue Previous Chat
Resume an existing conversation:
1. Open conversation list (sidebar)
2. Click on a previous chat
3. Continue from where you left off
## Sending Messages
### Text Messages
Simply type and send:
* Type your message
* Press `Enter` to send
* Press `Shift + Enter` for new line
### Formatting
Basic text formatting:
* **Bold**: `**text**` or `Ctrl/Cmd + B`
* *Italic*: `*text*` or `Ctrl/Cmd + I`
* `Code`: `` `text` ``
* Lists: Start with `-` or `1.`
### File Uploads
Send files to your AI assistant:
**Drag and Drop:**
* Drag file into chat window
* Drop to upload
**Click to Upload:**
* Click paperclip icon
* Select file from computer
* Click Open
**Supported Files:**
* Documents: PDF, DOCX, XLSX, TXT
* Images: JPG, PNG, GIF
* Archives: ZIP
* Max size: 25MB per file
### Images
Send images for analysis:
* Upload image
* AI can:
* Describe image content
* Extract text (OCR)
* Find similar products
* Answer questions about image
**Example:**
```
[Upload photo of shoes]
"Find me where to buy these"
```
### Voice Input
Use voice to text (if enabled):
1. Click microphone icon
2. Speak your message
3. Review transcription
4. Send
## Message Features
### Edit Messages
Edit your sent messages:
1. Hover over your message
2. Click edit icon
3. Modify text
4. Save changes
Editing regenerates AI's response based on new message
### Delete Messages
Remove messages:
1. Hover over message
2. Click delete icon
3. Confirm deletion
### Copy Messages
Copy text to clipboard:
1. Hover over message
2. Click copy icon
3. Paste anywhere
### Share Messages
Share specific messages:
1. Click share icon
2. Choose method:
* Copy link
* Email
* Social media
3. Share with others
## AI Response Features
### Streaming Responses
AI responses appear in real-time:
* Text streams as generated
* Stop generation anytime
* Regenerate if needed
### Code Blocks
AI-generated code with:
* Syntax highlighting
* Language indicator
* Copy button
* Download option
Example:
```python theme={null}
def hello_world():
print("Hello, World!")
```
### Action Buttons
Interactive buttons in responses:
* **Create Task** - Turn response into task
* **Add to Calendar** - Schedule mentioned event
* **Open Link** - Quick access to URLs
* **Download** - Save generated content
### Regenerate Response
Get a different answer:
1. Hover over AI response
2. Click regenerate icon
3. AI generates new response
### Rate Responses
Help improve AI:
* 👍 Thumbs up for good responses
* 👎 Thumbs down for poor responses
* Optional feedback comment
## Conversation Management
### Conversation Titles
Auto-generated titles based on first message:
* Edit title: Click on title
* Custom names help organization
### Search Within Conversation
Find specific messages:
1. Open conversation
2. Click search icon
3. Enter search term
4. Navigate results
### Pin Conversations
Keep important chats accessible:
1. Hover over conversation
2. Click pin icon
3. Pinned chats appear at top
### Archive Conversations
Clean up chat list:
1. Hover over conversation
2. Click archive icon
3. Access archived chats in Archive section
### Delete Conversations
Permanently remove chats:
1. Hover over conversation
2. Click delete icon
3. Confirm deletion
Deleted conversations cannot be recovered
## Advanced Features
### Context Awareness
AI remembers conversation history:
* Refers to previous messages
* Maintains context across messages
* Asks clarifying questions
**Example:**
```
You: "Schedule a meeting tomorrow at 2pm"
AI: "I'll schedule that. What should the meeting title be?"
You: "Team Sync"
AI: "✓ Created 'Team Sync' tomorrow at 2pm"
```
### Multi-turn Conversations
Handle complex requests:
* Break down into steps
* Confirm actions
* Provide options
* Follow-up questions
### File References
Reference uploaded files:
```
You: [Uploads report.pdf]
You: "Summarize the key findings"
AI: [Analyzes PDF and provides summary]
You: "What was the revenue figure?"
AI: "According to the report, revenue was $2.3M"
```
### Command Mode
Quick commands with `/`:
* `/help` - Show available commands
* `/clear` - Clear context
* `/history` - Show recent conversations
* `/settings` - Open settings
* `/feedback` - Send feedback
## Keyboard Shortcuts
Work faster with shortcuts:
| Action | Shortcut |
| ------------- | --------------- |
| New Chat | `Ctrl/Cmd + N` |
| Send Message | `Enter` |
| New Line | `Shift + Enter` |
| Search Chat | `Ctrl/Cmd + F` |
| Upload File | `Ctrl/Cmd + U` |
| Focus Input | `Esc` |
| Previous Chat | `Ctrl/Cmd + ↑` |
| Next Chat | `Ctrl/Cmd + ↓` |
## Mobile Chat Interface
### Mobile Layout
Optimized for mobile screens:
* Full-screen chat
* Swipe to access sidebar
* Touch-friendly buttons
* Auto-hide keyboard
### Mobile-Specific Features
**Voice Input:**
* Tap and hold to record
* Release to send
**Quick Actions:**
* Long-press message for menu
* Swipe left to delete
* Swipe right to share
**Image Upload:**
* Take photo directly
* Or choose from gallery
## Conversation Settings
### Per-Chat Settings
Customize each conversation:
1. Click settings icon (in chat)
2. Configure:
* AI response style
* Context retention
* Auto-save messages
* Notification preferences
### Response Preferences
Control AI behavior:
* **Length**: Concise, Balanced, Detailed
* **Formality**: Casual, Professional, Formal
* **Creativity**: Factual, Balanced, Creative
### Context Control
Manage conversation memory:
* **Full Context** - Remember everything
* **Recent Only** - Last 10 messages
* **No Context** - Each message independent
Clear context: `/clear` or button in settings
## Export Conversations
Save your chat history:
**Export Single Chat:**
1. Open conversation
2. Click menu (⋮)
3. Select **Export**
4. Choose format:
* TXT (plain text)
* JSON (structured data)
* PDF (formatted)
5. Download
**Export All Chats:**
* Settings > Data > **Export All Conversations**
## Notifications
### Chat Notifications
Get notified of:
* New AI responses
* Mentioned in shared chats (future)
* Failed message delivery
* Integration actions completed
Configure: Settings > Notifications > Chat
### Desktop Notifications
Enable browser notifications:
1. Settings > Notifications
2. Enable **Desktop Notifications**
3. Grant browser permission
4. Choose notification sound
## Collaboration (Future)
Upcoming features:
* Share conversations with team
* Collaborative AI sessions
* Comment on messages
* Team workspaces
## Troubleshooting
### Messages Not Sending
* Check internet connection
* Verify file size limit
* Try refreshing page
* Check browser console
### AI Not Responding
* Wait for current response to complete
* Check if connection was lost
* Refresh page
* Try regenerating response
### Slow Responses
* Large file uploads take time
* Complex queries need processing
* Check server status page
* Try simpler queries first
### Formatting Issues
* Ensure proper markdown syntax
* Check code block formatting
* Try plain text first
* Report persistent issues
## Best Practices
### Effective Prompts
Write clear messages:
* Be specific and detailed
* Provide context
* Break complex requests into steps
* Use examples when helpful
### Organization
Keep chats organized:
* Use descriptive titles
* Archive completed conversations
* Pin important ongoing chats
* Delete unnecessary chats
### Privacy
Protect sensitive information:
* Don't share passwords
* Avoid confidential data in titles
* Use private browsing for sensitive chats
* Clear chat history when needed
## Tips & Tricks
**Quick File Upload:**
* Screenshot: Paste directly with `Ctrl/Cmd + V`
* Drag multiple files at once
**Fast Navigation:**
* Use keyboard shortcuts
* Pin frequent chats
* Use search instead of scrolling
**Better Responses:**
* Provide context in first message
* Reference previous messages
* Use specific language
* Ask follow-up questions
## Next Steps
Learn about dashboard features
See what you can do with Praxos
Connect your services
Detailed integration documentation
# Dashboard Guide
Source: https://docs.mypraxos.com/webapp/dashboard
Navigate and customize your Praxos dashboard
## Dashboard Overview
Your Praxos dashboard is your command center, providing at-a-glance insights into your AI assistant's activity, integrations, and upcoming tasks.
## Dashboard Layout
### Main Sections
The dashboard is organized into key areas:
**Header Section**
* Welcome message with date/time
* Quick search bar
* Notification center
* User profile menu
**Content Area**
* Customizable widgets
* Activity feed
* Quick actions panel
**Sidebar**
* Navigation menu
* Integration status
* Shortcut links
## Default Widgets
### Recent Conversations
Shows your latest chat sessions:
* Last 5-10 conversations
* Conversation preview
* Timestamp
* Platform icon (web, Telegram, Discord, etc.)
**Actions:**
* Click to resume conversation
* Archive conversation
* Delete conversation
### Upcoming Events
Displays events from connected calendars:
* Next 7 days by default
* Event time and title
* Attendees (if any)
* Location/meeting link
**Actions:**
* Click to view details
* Join meeting (if virtual)
* Reschedule event
* Add to another calendar
### Task Summary
Overview of your tasks and reminders:
* Pending tasks (count)
* Completed today (count)
* Overdue tasks (if any)
* Next upcoming deadline
**Actions:**
* View all tasks
* Mark task complete
* Snooze reminder
* Create new task
### Integration Status
Monitor your connected services:
* Active integrations
* Connection health status
* Last sync time
* Any errors or warnings
**Actions:**
* Re-authorize integration
* Test connection
* View integration details
* Disconnect service
### Quick Stats
Key metrics at a glance:
* Messages sent/received this week
* Tasks completed
* Files processed
* API usage
### Activity Feed
Recent activity across all integrations:
* New emails received
* Calendar events created
* Tasks completed
* Files uploaded
* Integration connections
## Customizing Your Dashboard
### Add/Remove Widgets
1. Click the **Edit Dashboard** button (top-right)
2. Click **Add Widget**
3. Select from available widgets
4. Drag to position
5. Click **Save** when done
### Rearrange Widgets
In edit mode:
1. Click and hold widget header
2. Drag to new position
3. Drop in place
4. Resize by dragging corners (if supported)
### Widget Settings
Each widget has its own settings:
1. Click the settings icon on widget
2. Configure options:
* Data source
* Display count
* Time range
* Sort order
3. Save changes
## Quick Actions
### Common Actions
Access frequent operations quickly:
* **New Chat** - Start a conversation
* **Schedule Event** - Create calendar event
* **Upload File** - Upload and process file
* **Create Task** - Add reminder or task
* **Connect Integration** - Add new service
### Custom Quick Actions
Create your own shortcuts:
1. Go to Settings > Dashboard > Quick Actions
2. Click **Add Custom Action**
3. Define:
* Action name
* Command or link
* Icon
4. Save
Examples:
* "Daily Briefing" → Triggers morning summary
* "Check Email" → Opens unread emails
* "Today's Schedule" → Shows calendar
## Search Functionality
### Global Search
The search bar (`Ctrl/Cmd + K`) finds:
* Past conversations
* Messages
* Files
* Tasks
* Calendar events
* Integration data
**Search Tips:**
* Use quotes for exact phrases: `"project alpha"`
* Filter by type: `type:file`, `type:task`, `type:email`
* Filter by date: `date:today`, `date:this week`
* Filter by integration: `from:gmail`, `from:trello`
### Search Filters
Refine results with filters:
* **Date Range** - Specific time period
* **Content Type** - Messages, files, tasks, etc.
* **Integration** - Specific service
* **Status** - Complete, pending, archived
## Notifications Center
### Notification Types
The bell icon shows:
* **System** - Updates, maintenance, features
* **Integration** - Connection issues, new data
* **Tasks** - Reminders, due dates
* **Activity** - Mentions, responses, shared items
### Managing Notifications
**Mark as Read:**
* Click individual notification
* Or click "Mark all as read"
**Notification Settings:**
* Go to Settings > Notifications
* Enable/disable by type
* Set quiet hours
* Configure email digests
### Do Not Disturb
Temporarily pause notifications:
1. Click notification bell
2. Click **Do Not Disturb**
3. Select duration:
* 30 minutes
* 1 hour
* Until tomorrow
* Custom time
## Dashboard Themes
### Light/Dark Mode
Switch between themes:
* Click profile picture
* Select **Appearance**
* Choose Light, Dark, or Auto (system)
### Compact View
For more information density:
* Settings > Appearance > **Compact View**
* Reduces padding and spacing
* Shows more content
### Custom Accent Color
Personalize your interface:
* Settings > Appearance > **Accent Color**
* Choose from presets
* Or enter custom hex code
## Mobile Dashboard
### Mobile Layout
On mobile devices, the dashboard adapts:
* Single column layout
* Collapsible sections
* Swipe gestures
* Bottom navigation bar
### Mobile Widgets
Priority widgets shown first:
* Recent conversations
* Today's calendar
* Urgent tasks
* Quick actions
### Pull to Refresh
Update your dashboard:
* Pull down from top
* Release to refresh
* Updates all widgets
## Performance Tips
### Load Time Optimization
Speed up your dashboard:
* Limit widgets to essential ones
* Reduce data ranges (e.g., last 7 days vs 30)
* Disable unused integrations
* Clear cache regularly
### Data Sync
Control sync frequency:
* Settings > Advanced > **Sync Frequency**
* Options: Real-time, 5 min, 15 min, hourly
* Balance between freshness and performance
## Keyboard Shortcuts
Navigate faster with shortcuts:
| Action | Shortcut |
| ------------------ | ---------------------- |
| Focus Search | `Ctrl/Cmd + K` |
| New Chat | `Ctrl/Cmd + N` |
| Refresh Dashboard | `Ctrl/Cmd + R` |
| Open Notifications | `Ctrl/Cmd + Shift + N` |
| Open Settings | `Ctrl/Cmd + ,` |
| Navigate Widgets | `Tab` / `Shift + Tab` |
## Dashboard Presets
### Templates
Choose from preset layouts:
* **Focus Mode** - Minimal, conversation-focused
* **Power User** - All widgets, maximum info
* **Productivity** - Tasks and calendar focused
* **Communication** - Email and messaging focused
To apply:
1. Edit Dashboard
2. Click **Load Preset**
3. Select template
4. Customize if needed
5. Save
### Save Your Layout
Save custom layouts:
1. Arrange dashboard as desired
2. Click **Save Layout As...**
3. Name your preset
4. Switch between layouts anytime
## Integration Widgets
### Integration-Specific Widgets
When you connect services, new widgets become available:
**Gmail Widget:**
* Unread count
* Recent emails
* Priority inbox
**Google Calendar Widget:**
* Today's events
* Week view
* Meeting rooms status
**Trello Widget:**
* Active boards
* Assigned cards
* Due soon items
**Notion Widget:**
* Recent pages
* Database views
* Quick create
## Analytics Dashboard
### Usage Statistics
Premium feature showing:
* Message volume over time
* Most used integrations
* Task completion rates
* Response time metrics
* Peak usage hours
Location: Dashboard > **Analytics** tab
### Export Data
Download your activity data:
1. Go to Dashboard > Analytics
2. Click **Export**
3. Select date range
4. Choose format (CSV, JSON, PDF)
5. Download
## Troubleshooting
### Widgets Not Loading
* Refresh page
* Check internet connection
* Verify integration status
* Clear browser cache
### Outdated Information
* Click refresh icon on widget
* Check sync settings
* Re-authorize integration if needed
### Layout Issues
* Reset to default layout
* Clear browser cache
* Try different browser
* Report issue to support
## Best Practices
### Dashboard Organization
* Keep frequently used widgets at top
* Limit widgets to 6-8 for optimal performance
* Group related widgets together
* Use custom quick actions for workflows
### Regular Maintenance
* Review and remove unused widgets weekly
* Update integration connections
* Archive old conversations
* Check notification settings
## Next Steps
Learn about the conversation interface
Set up your services and tools
# Getting Started with Praxos Web
Source: https://docs.mypraxos.com/webapp/getting-started
Sign up and start using Praxos in your browser
## Create Your Account
### Step 1: Visit mypraxos.com
Navigate to [mypraxos.com](https://mypraxos.com) in your web browser.
### Step 2: Sign Up
Click the "Sign Up" or "Get Started" button to create your account.
**Choose your sign-up method:**
* Email & Password
* Google Sign-In
* Microsoft Account
* GitHub Account
### Step 3: Verify Email
Check your email for a verification link and click it to activate your account.
### Step 4: Complete Profile
Fill in your profile information:
* Name
* Time zone
* Language preference
* Notification preferences
## First Time Setup
### Welcome Tour
On your first login, you'll be greeted with a welcome tour that covers:
* Dashboard overview
* Chat interface
* Integration setup
* Settings panel
You can always access the tour again from Settings > Help > Take Tour
### Connect Your First Integration
Start by connecting one of your favorite platforms:
1. Click "Integrations" in the sidebar
2. Choose a platform (e.g., Google Calendar, Gmail, Telegram)
3. Click "Connect"
4. Follow the OAuth authorization flow
5. Grant necessary permissions
**Recommended first integrations:**
* Google Calendar (for scheduling)
* Gmail (for email management)
* Telegram (for mobile access)
### Start Your First Conversation
1. Click on the chat icon or "New Chat"
2. Type your first message
3. Press Enter or click Send
**Try these starter messages:**
```
"Hello! What can you help me with?"
"Show me what integrations I have connected"
"What's on my calendar today?"
```
## Navigation Overview
### Main Navigation
The sidebar contains:
* **Home** - Dashboard overview
* **Chat** - Conversation interface
* **Integrations** - Manage connected services
* **Tasks** - Scheduled tasks and reminders
* **Files** - Uploaded and processed files
* **Settings** - Account and preferences
### Top Bar
The top bar includes:
* Search functionality
* Notification center
* User profile menu
* Quick actions button
## Dashboard Widgets
Your dashboard can include:
* **Recent Conversations** - Latest chat sessions
* **Upcoming Events** - From connected calendars
* **Task Summary** - Pending and completed tasks
* **Integration Status** - Connected services health
* **Quick Actions** - Common shortcuts
Customize your dashboard layout from Settings > Dashboard
## Keyboard Shortcuts
Speed up your workflow with keyboard shortcuts:
| Action | Shortcut |
| ------------------- | --------------- |
| New Chat | `Ctrl/Cmd + N` |
| Search | `Ctrl/Cmd + K` |
| Settings | `Ctrl/Cmd + ,` |
| Send Message | `Enter` |
| New Line in Message | `Shift + Enter` |
| Upload File | `Ctrl/Cmd + U` |
View all shortcuts: Settings > Keyboard Shortcuts
## Mobile Access
### Install as PWA
Install Praxos as a Progressive Web App on your device:
**On Chrome/Edge:**
1. Visit mypraxos.com
2. Click the install icon in the address bar
3. Click "Install"
**On Safari (iOS):**
1. Visit mypraxos.com
2. Tap the Share button
3. Select "Add to Home Screen"
### Mobile Navigation
On mobile devices:
* Access menu via hamburger icon (top-left)
* Swipe to navigate between sections
* Long-press for context menus
* Pull down to refresh
## Privacy & Security
### Two-Factor Authentication
Enable 2FA for extra security:
1. Go to Settings > Security
2. Click "Enable Two-Factor Authentication"
3. Scan QR code with authenticator app
4. Enter verification code
5. Save backup codes
### Active Sessions
Manage your active sessions:
* View all logged-in devices
* Revoke access from specific devices
* Set session timeout preferences
Location: Settings > Security > Active Sessions
### Data Privacy
Control your data:
* Export your data
* Delete specific conversations
* Clear message history
* Manage integration access
Location: Settings > Privacy
## Customization
### Appearance
Customize the look:
* Light/Dark theme
* Accent color
* Font size
* Compact/Comfortable view
Location: Settings > Appearance
### Notifications
Configure how you're notified:
* Browser notifications
* Email digests
* Sound alerts
* Do Not Disturb schedule
Location: Settings > Notifications
### AI Behavior
Customize AI responses:
* Response length (concise, balanced, detailed)
* Formality level (casual, professional, formal)
* Proactivity (conservative, balanced, proactive)
* Default language
Location: Settings > AI Preferences
## Getting Help
### In-App Help
Access help resources:
* Documentation (this site)
* Video tutorials
* FAQ
* Feature guides
Location: Help icon (?) in top bar
### Support
Need assistance?
* **Live Chat** - In-app chat support
* **Email** - [support@mypraxos.com](mailto:support@mypraxos.com)
* **Community** - Community forum
* **Status Page** - status.mypraxos.com
### Report Issues
Found a bug?
1. Click your profile picture
2. Select "Report Issue"
3. Describe the problem
4. Attach screenshots if helpful
5. Submit
## Best Practices
### Organization
* Use clear message subjects
* Archive old conversations
* Tag important messages
* Create custom folders
### Security
* Use strong passwords
* Enable 2FA
* Review active sessions regularly
* Don't share credentials
### Efficiency
* Learn keyboard shortcuts
* Set up quick actions
* Use templates for common requests
* Customize dashboard widgets
## Next Steps
Learn about dashboard features and widgets
Discover advanced chat features
Connect your favorite services
See what you can do with Praxos
## Troubleshooting
### Can't Log In
* Verify email address is correct
* Check if email is verified
* Try password reset
* Clear browser cache
* Try incognito/private mode
### Integration Not Working
* Check integration status
* Re-authorize connection
* Verify permissions granted
* Check service status page
### Messages Not Sending
* Check internet connection
* Verify file size limits
* Try refreshing page
* Check browser console for errors
### Performance Issues
* Clear browser cache
* Disable browser extensions
* Try different browser
* Check system resources
For persistent issues, contact support at [support@mypraxos.com](mailto:support@mypraxos.com)
# Setting Up Integrations
Source: https://docs.mypraxos.com/webapp/integrations-setup
Connect your favorite services through the Praxos web app
## Overview
The Praxos web application provides the easiest way to connect and manage your integrations through visual OAuth flows and intuitive configuration interfaces.
## Integration Dashboard
Access integrations from the sidebar:
* Click **Integrations** in navigation
* View all available integrations
* See connection status
* Manage existing connections
## Connection Process
### OAuth Integrations
For services that use OAuth (Google, Microsoft, Notion, etc.):
**Step 1: Select Integration**
1. Go to Integrations page
2. Find the service you want to connect
3. Click **Connect** button
**Step 2: Authorization**
1. You'll be redirected to the service's login page
2. Sign in with your account
3. Review requested permissions
4. Click **Allow** or **Authorize**
**Step 3: Confirmation**
1. You'll be redirected back to Praxos
2. Connection status shows as **Connected**
3. Integration is ready to use
### API Key Integrations
For services that use API keys (Trello, etc.):
**Step 1: Get API Credentials**
1. Visit the service's developer portal
2. Create an API key or token
3. Copy the credentials
**Step 2: Add to Praxos**
1. Click **Connect** on the integration
2. Paste API key in the field
3. Click **Save**
4. Test connection
## Available Integrations
### Messaging Platforms
Connect your Telegram bot for mobile access
Add Praxos to your Discord servers
Integrate with your Slack workspace
Connect via WhatsApp Business API
**Setup Guide:** [Messaging Platform Integration Guides](/integrations/overview)
### Google Services
**Connect Once, Access All:**
When you connect Google, you can choose which services to enable:
* ✅ Gmail - Email management
* ✅ Google Calendar - Event scheduling
* ✅ Google Drive - File storage
* ✅ Google Search - Web search
**Setup Steps:**
1. Click **Connect Google**
2. Sign in with Google account
3. Review and accept permissions:
* Read/send emails
* Manage calendar events
* Access Drive files
4. Click **Allow**
5. Choose which services to enable
6. Done!
**Detailed Guide:** [Google Integration](/integrations/google)
### Microsoft 365
**Available Services:**
* Outlook Email
* Outlook Calendar
* OneDrive
* Teams (coming soon)
**Setup Steps:**
1. Click **Connect Microsoft**
2. Sign in with Microsoft account
3. Grant permissions for selected services
4. Click **Accept**
5. Connection established
**Detailed Guide:** [Microsoft Integration](/integrations/microsoft)
### Productivity Tools
Access your Notion workspace
Manage Trello boards and cards
File storage and sharing
## Managing Connections
### View Connection Status
Check integration health:
* **Connected** (green) - Working properly
* **Needs Attention** (yellow) - Needs re-auth
* **Disconnected** (red) - Not connected
* **Syncing** (blue) - Currently syncing data
### Test Connection
Verify integration is working:
1. Click on connected integration
2. Click **Test Connection**
3. View test results
4. Fix any issues if needed
### Re-authorize
If connection expires or has issues:
1. Click on integration
2. Click **Re-authorize**
3. Complete OAuth flow again
4. Connection restored
### Disconnect
Remove an integration:
1. Click on connected integration
2. Scroll to bottom
3. Click **Disconnect**
4. Confirm disconnection
Disconnecting removes access to that service. You can reconnect anytime.
## Permission Management
### Review Permissions
See what access Praxos has:
1. Click on integration
2. Go to **Permissions** tab
3. View granted permissions
4. Understand what each permission allows
### Modify Permissions
Some integrations allow selective permissions:
1. Click **Edit Permissions**
2. Enable/disable specific access
3. Save changes
4. May require re-authorization
### Revoke Access
Remove Praxos access from service side:
1. Visit service's account settings
2. Find connected apps/integrations
3. Locate Praxos
4. Click Revoke or Remove
5. Disconnect in Praxos too
## Integration Settings
### Sync Preferences
Control how data syncs:
* **Sync Frequency** - Real-time, hourly, daily
* **Sync Direction** - Read-only, read-write
* **Data Range** - Last 30 days, 90 days, all time
### Notification Settings
Configure per-integration notifications:
* New items (emails, events, etc.)
* Errors or connection issues
* Sync completion
* Rate limit warnings
### Usage Limits
Monitor API usage:
* **Requests Used** - Current period usage
* **Requests Remaining** - Before limit
* **Rate Limit** - Requests per hour/day
* **Reset Time** - When limit resets
## Telegram Setup
Telegram is the easiest messaging platform to set up:
### Create Bot
1. Open Telegram
2. Search for @BotFather
3. Send `/newbot`
4. Follow prompts to name your bot
5. Copy the bot token provided
### Connect in Praxos
1. Go to Integrations > Telegram
2. Click **Connect**
3. Paste bot token
4. Click **Save**
5. Test: Send message to your bot
### Use Your Bot
1. Find your bot in Telegram (search for username)
2. Start chat with `/start`
3. Begin talking to Praxos through Telegram
**Full Guide:** [Telegram Integration](/integrations/telegram)
## Discord Setup
### Create Discord Application
1. Go to [Discord Developer Portal](https://discord.com/developers/applications)
2. Click **New Application**
3. Name it "Praxos"
4. Go to **Bot** section
5. Click **Add Bot**
6. Copy bot token
### Connect in Praxos
1. Go to Integrations > Discord
2. Click **Connect**
3. Enter bot token and application ID
4. Click **Save**
### Invite to Server
1. Praxos generates invite URL
2. Click **Invite to Server**
3. Select Discord server
4. Grant permissions
5. Authorize
**Full Guide:** [Discord Integration](/integrations/discord)
## Slack Setup
### Create Slack App
1. Go to [api.slack.com/apps](https://api.slack.com/apps)
2. Click **Create New App**
3. Choose **From scratch**
4. Name: "Praxos"
5. Select workspace
### Install to Workspace
1. In Praxos: Click **Connect Slack**
2. Follow OAuth flow
3. Select workspace
4. Review permissions
5. Click **Allow**
### Use in Slack
1. Invite @Praxos to channel: `/invite @Praxos`
2. Mention bot: `@Praxos help me`
3. Or DM the bot directly
**Full Guide:** [Slack Integration](/integrations/slack)
## Troubleshooting
### Connection Failed
**Possible causes:**
* Network issues
* Invalid credentials
* Insufficient permissions
* Service is down
**Solutions:**
* Check internet connection
* Verify credentials are correct
* Grant all required permissions
* Check service status page
* Try again in a few minutes
### Sync Issues
**Symptoms:**
* Old data showing
* Missing recent items
* Sync never completes
**Solutions:**
* Click **Sync Now** button
* Check sync settings
* Verify service access hasn't been revoked
* Re-authorize if needed
* Contact support if persistent
### Permission Errors
**Error: "Insufficient permissions"**
**Fix:**
1. Click **Re-authorize**
2. Ensure all permissions are granted
3. Check service settings for restrictions
4. Verify account has necessary access
### Rate Limits
**Error: "Rate limit exceeded"**
**What happened:**
You've hit the API rate limit for that service.
**Solutions:**
* Wait for rate limit to reset (shown in integration)
* Reduce sync frequency
* Spread usage over time
* Upgrade service plan if available
## Best Practices
### Security
* Use strong passwords for all accounts
* Enable 2FA on connected services
* Regularly review connected apps
* Revoke access for unused integrations
* Don't share integration credentials
### Organization
* Connect integrations as needed
* Disconnect unused integrations
* Use descriptive names for OAuth apps
* Review permissions periodically
* Keep credentials updated
### Performance
* Set appropriate sync frequencies
* Don't connect duplicate integrations
* Monitor rate limits
* Clear old data regularly
## Integration-Specific Tips
### Gmail
* Grant both read and send permissions for full functionality
* Use labels for organization
* Set up filters in Gmail for Praxos actions
* Consider a dedicated Gmail account
### Google Calendar
* Connect all calendars you want to manage
* Set default calendar for new events
* Enable notifications for calendar changes
* Sync both work and personal calendars
### Notion
* Share specific pages/databases with Praxos integration
* Use templates for consistent structure
* Organize with databases
* Regular database cleanup
### Trello
* Connect boards you actively use
* Set up Power-Ups in Trello for enhanced features
* Use labels and due dates consistently
* Archive completed boards
## Advanced Setup
### Multiple Accounts
Connect multiple accounts of the same service:
1. First account: Standard OAuth flow
2. Additional accounts:
* Click **Add Another Account**
* Complete OAuth for second account
3. Label each account (e.g., "Work Gmail", "Personal Gmail")
4. Choose default account in settings
### Webhook Configuration
For real-time updates (advanced users):
1. Go to integration settings
2. Enable **Webhooks**
3. Copy webhook URL
4. Configure in service (if supported)
5. Test webhook
6. Receive instant notifications
### Custom Integration
Need a service not listed?
* Check **Community Integrations** tab
* Or request new integration: [feedback@mypraxos.com](mailto:feedback@mypraxos.com)
* Enterprise: Custom integration development available
## Getting Help
### Integration Support
* **Documentation** - Detailed guides for each service
* **In-App Help** - Context-sensitive help in each integration
* **Community** - Forum for user discussions
* **Support** - Email [support@mypraxos.com](mailto:support@mypraxos.com)
### Common Resources
* [Google Workspace Admin](https://admin.google.com)
* [Microsoft Admin Center](https://admin.microsoft.com)
* [Notion Workspace Settings](https://notion.so/my-integrations)
* [Trello Power-Ups](https://trello.com/power-ups)
## Next Steps
Detailed setup for each integration
See what you can do with integrations
Learn about available capabilities
Monitor your integrations
# Web Application Overview
Source: https://docs.mypraxos.com/webapp/overview
Access Praxos through your browser at mypraxos.com
## What is Praxos Web?
Praxos Web is your browser-based interface to access your AI Second Brain Intelligence. Available at [mypraxos.com](https://mypraxos.com), the web application provides a comprehensive dashboard for managing your AI assistant, conversations, integrations, and more.
## Key Features
### Chat Interface
* **Conversational AI** - Natural language interaction with your AI assistant
* **Message History** - Access all your previous conversations
* **Multi-modal Support** - Text, images, files, and voice messages
* **Real-time Responses** - Instant AI responses with streaming support
### Dashboard
* **Overview** - Quick stats and recent activity
* **Task Management** - View and manage scheduled tasks
* **Calendar Integration** - See your upcoming events
* **Quick Actions** - Common actions at your fingertips
### Integration Management
* **Connect Services** - Easy OAuth flows for integrations
* **Manage Credentials** - Securely store and update API keys
* **Test Connections** - Verify integration status
* **Usage Statistics** - Track integration activity
### Settings & Preferences
* **Profile Management** - Update your personal information
* **Notification Settings** - Configure alerts and notifications
* **AI Preferences** - Customize AI behavior and response style
* **Privacy Controls** - Manage data and privacy settings
## Why Use the Web App?
### Accessibility
Access Praxos from any device with a web browser:
* Desktop computers
* Laptops
* Tablets
* Mobile devices
### Visual Interface
The web app provides a richer visual experience:
* Interactive dashboards
* Visual file management
* Rich message formatting
* Drag-and-drop file uploads
### Management & Configuration
Easily manage your Praxos setup:
* Visual integration setup
* OAuth connection flows
* Settings management
* Usage analytics
## Web App vs Messaging Platforms
| Feature | Web App | Telegram/Discord/Slack |
| ----------------- | -------------------- | ----------------------- |
| Chat Interface | ✅ Full-featured | ✅ Native messaging |
| File Uploads | ✅ Drag & drop | ✅ Attachments |
| Dashboard | ✅ Comprehensive | ❌ Not available |
| Integration Setup | ✅ Visual OAuth | ⚙️ Manual configuration |
| Task Management | ✅ Visual interface | 📝 Text-based |
| Calendar View | ✅ Visual calendar | 📝 Text list |
| Settings | ✅ Full control panel | ⚙️ Limited commands |
| Notifications | 🔔 In-app | 🔔 Native platform |
## Getting Started
Sign up and set up your Praxos account
Learn your way around the dashboard
Start conversations with your AI assistant
Set up your favorite services and tools
## Availability
The Praxos web application is available at:
* **Production**: [mypraxos.com](https://mypraxos.com)
* **Support**: Available through in-app chat or email
## Browser Compatibility
Praxos Web works best on modern browsers:
* ✅ Chrome/Edge (recommended)
* ✅ Firefox
* ✅ Safari
* ✅ Mobile browsers
## Security
Your data is protected with:
* HTTPS encryption
* Secure authentication
* OAuth 2.0 for integrations
* Regular security audits
* Data encryption at rest
## Mobile Experience
The web app is fully responsive and optimized for mobile:
* Touch-friendly interface
* Mobile navigation
* Optimized layouts
* Fast loading times
## Next Steps
Create your account and start using Praxos in your browser