Skip to main content

​
Overview

Parsaa supports multiple AI models, each with different strengths and capabilities. This guide helps you choose the best model for your specific development tasks and requirements.
Model Selection: You can switch between models easily, and Parsaa can automatically select the best model for each task.

​
Model Categories

​
General Purpose Models

Best For: Complex reasoning, code analysis, and creative problem-solvingStrengths:
  • Excellent code understanding
  • Strong reasoning capabilities
  • Great for complex refactoring
  • Good at explaining code
Use Cases:
  • Complex code analysis
  • Architectural decisions
  • Debugging difficult issues
  • Code reviews
Cost: Higher cost but excellent quality
Best For: Balanced performance and cost for most development tasksStrengths:
  • Good balance of speed and quality
  • Excellent at following instructions
  • Strong code generation
  • Good documentation skills
Use Cases:
  • General code generation
  • Documentation writing
  • Code explanations
  • Test generation
Cost: Moderate cost with good quality
Best For: Fast responses and cost-effective developmentStrengths:
  • Very fast response times
  • Good code understanding
  • Cost-effective
  • Good at multiple languages
Use Cases:
  • Quick code fixes
  • Simple refactoring
  • Basic code generation
  • Learning and experimentation
Cost: Lower cost with decent quality

​
Specialized Models

Best For: Code-specific tasks and Swift developmentStrengths:
  • Specialized for code generation
  • Good at Swift and iOS development
  • Open-source alternative
  • Can run locally
Use Cases:
  • Swift code generation
  • iOS-specific patterns
  • Code completion
  • Local processing
Cost: Free when running locally
Best For: Most complex and demanding tasksStrengths:
  • Highest reasoning capability
  • Excellent code analysis
  • Best for complex problems
  • Superior understanding
Use Cases:
  • Complex architectural decisions
  • Advanced debugging
  • Research and analysis
  • Critical code reviews
Cost: Highest cost but best quality
Best For: Fast, cost-effective tasksStrengths:
  • Very fast responses
  • Cost-effective
  • Good for simple tasks
  • Reliable performance
Use Cases:
  • Quick code fixes
  • Simple explanations
  • Basic code generation
  • Learning and practice
Cost: Lowest cost with good performance

​
Task-Specific Recommendations

​
Code Analysis and Review

  • Complex Analysis
  • Quick Review
  • Basic Analysis
Recommended: GPT-4 or Claude-3 Opus
  • Best for understanding complex codebases
  • Excellent at identifying architectural issues
  • Great for security analysis
  • Superior reasoning capabilities

​
Code Generation

  • Swift/SwiftUI
  • General Purpose
  • Rapid Prototyping
Recommended: GPT-4 or Code Llama
  • Best understanding of Swift patterns
  • Excellent iOS development knowledge
  • Great at SwiftUI generation
  • Strong iOS ecosystem knowledge

​
Code Refactoring

  • Complex Refactoring
  • Style Improvements
  • Quick Fixes
Recommended: GPT-4 or Claude-3 Opus
  • Best understanding of code relationships
  • Excellent at preserving functionality
  • Great for architectural improvements
  • Superior reasoning about changes

​
Performance vs Cost Analysis

​
High Performance Models

GPT-4

Quality: ⭐⭐⭐⭐⭐ Speed: ⭐⭐⭐ Cost: ⭐⭐Best for complex tasks requiring highest quality

Claude-3 Opus

Quality: ⭐⭐⭐⭐⭐ Speed: ⭐⭐⭐ Cost: ⭐⭐Best for most demanding tasks

​
Balanced Models

Claude-3 Sonnet

Quality: ⭐⭐⭐⭐ Speed: ⭐⭐⭐⭐ Cost: ⭐⭐⭐Best overall balance for most users

Gemini Pro

Quality: ⭐⭐⭐⭐ Speed: ⭐⭐⭐⭐⭐ Cost: ⭐⭐⭐⭐Great for speed and cost balance

​
Cost-Effective Models

GPT-3.5 Turbo

Quality: ⭐⭐⭐ Speed: ⭐⭐⭐⭐⭐ Cost: ⭐⭐⭐⭐⭐Best for simple tasks and learning

Code Llama

Quality: ⭐⭐⭐ Speed: ⭐⭐⭐⭐ Cost: ⭐⭐⭐⭐⭐Free when running locally

​
Local vs Cloud Models

​
Local Models

  • Complete Privacy: No data leaves your machine
  • No Internet Required: Works offline
  • No Per-Request Costs: One-time setup cost
  • Full Control: Complete control over processing
  • Custom Models: Use your own fine-tuned models
  • Hardware Requirements: Need powerful hardware
  • Limited Models: Fewer model options
  • Slower Setup: Initial setup can be complex
  • Maintenance: Need to manage models yourself
  • Quality: May not match cloud model quality

​
Cloud Models

  • No Hardware Requirements: Works on any machine
  • Latest Models: Access to newest AI models
  • Easy Setup: Simple configuration
  • High Quality: Best available AI capabilities
  • Automatic Updates: Always up-to-date
  • Internet Required: Needs internet connection
  • Per-Request Costs: Pay for each use
  • Privacy Concerns: Data sent to external servers
  • Rate Limits: May have usage restrictions
  • Dependency: Relies on external services

​
Automatic Model Selection

​
Smart Routing

Parsaa automatically selects the best model based on:
  • Task Complexity: Complex tasks use more capable models
  • Code Size: Large files use models with larger context windows
  • Sensitivity: Sensitive code uses local models
  • Cost Budget: Stays within your spending limits
  • Performance Requirements: Balances speed and quality
{
  "auto_selection": {
    "enabled": true,
    "cost_limit": 100,
    "quality_threshold": 0.8,
    "prefer_local": true,
    "fallback_models": ["gpt-3.5-turbo", "claude-3-haiku"]
  }
}

​
Manual Override

You can always override automatic selection:
  • Project Settings: Set model per project
  • File Settings: Different models for different file types
  • Task Settings: Specific models for specific tasks
  • Temporary Override: One-time model selection
Set your preferences for:
  • Default Model: Your preferred model
  • Backup Models: Fallback options
  • Cost Limits: Maximum spending per request
  • Quality Requirements: Minimum quality thresholds

​
Model Comparison Table

ModelQualitySpeedCostBest ForLocal
GPT-4⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐Complex analysis❌
Claude-3 Opus⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐Most demanding tasks❌
Claude-3 Sonnet⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐Balanced performance❌
Claude-3 Haiku⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐Fast, simple tasks❌
Gemini Pro⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐Speed and cost balance❌
GPT-3.5 Turbo⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐Cost-effective tasks❌
Code Llama⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐Local processing✅
Mistral⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐Local alternative✅

​
Recommendations by Use Case

​
For iOS/Swift Development

Claude-3 Sonnet - Best overall choice for Swift development
  • Excellent Swift understanding
  • Good balance of quality and cost
  • Great at iOS-specific patterns
  • Reliable performance
  • GPT-4: For complex architectural decisions
  • Code Llama: For local processing and privacy
  • Gemini Pro: For fast, cost-effective development

​
For Learning and Experimentation

GPT-3.5 Turbo - Best for learning and experimentation
  • Very cost-effective
  • Good enough quality for learning
  • Fast responses
  • Great for trying new things
  • Claude-3 Haiku: Slightly better quality
  • Code Llama: Free local option
  • Gemini Pro: Good balance for learning

​
For Production Development

GPT-4 - Best for production-quality code
  • Highest quality analysis
  • Excellent code generation
  • Best for complex problems
  • Superior reasoning
  • Claude-3 Opus: Similar quality, different strengths
  • Claude-3 Sonnet: Good balance for most tasks
  • Local Models: For maximum privacy

​
Cost Optimization Tips

​
Smart Usage Patterns

  • Use expensive models only for complex tasks
  • Switch to cheaper models for simple tasks
  • Use local models for sensitive code
  • Batch similar requests together
  • Reduce unnecessary context in requests
  • Use specific, focused questions
  • Avoid sending entire files when possible
  • Use semantic search to find relevant code

​
Budget Management

  • Set daily spending limits
  • Use cheaper models during development
  • Save expensive models for critical tasks
  • Monitor usage through analytics
  • Share model costs across team
  • Use team-wide model preferences
  • Implement usage policies
  • Track team spending

​
Getting Started

​
Quick Setup

1

Choose Your Primary Model

Start with Claude-3 Sonnet for balanced performance
2

Configure Auto-Selection

Enable automatic model selection in settings
3

Set Cost Limits

Configure daily and monthly spending limits
4

Test Different Models

Try different models for different tasks
5

Optimize Based on Usage

Adjust settings based on your actual usage patterns

​
Advanced Configuration

Set up custom rules for model selection:
  • File Type: Different models for different file types
  • Project Type: Different models for different projects
  • Time of Day: Different models for different times
  • User Role: Different models for different team members
Track and analyze model performance:
  • Response Quality: Rate model responses
  • Speed Metrics: Track response times
  • Cost Analysis: Monitor spending per model
  • Usage Patterns: Understand when to use which model
Pro Tip: Start with automatic model selection and let Parsaa learn your preferences. You can always override specific choices when needed.