> ## Documentation Index
> Fetch the complete documentation index at: https://docs.remind.tools/llms.txt
> Use this file to discover all available pages before exploring further.

# Google Gemini Integration

> AI-powered features using Google Gemini Pro

# Google Gemini Integration

Documentation for integrating Google Gemini Pro AI capabilities into Remind Tools.

## Setup

### API Key Configuration

```bash theme={null}
# .env file
GEMINI_API_KEY=your_api_key_here
```

### Client Initialization

```dart theme={null}
import 'package:google_generative_ai/google_generative_ai.dart';

class GeminiService {
  late final GenerativeModel _model;
  
  GeminiService() {
    _model = GenerativeModel(
      model: 'gemini-pro',
      apiKey: Environment.geminiApiKey,
      generationConfig: GenerationConfig(
        temperature: 0.7,
        topK: 40,
        topP: 0.95,
        maxOutputTokens: 1024,
      ),
    );
  }
}
```

## Use Cases

### Trip Itinerary Generation

```dart theme={null}
Future<String> generateItinerary({
  required String destination,
  required int days,
  required List<String> interests,
}) async {
  final prompt = '''
    Create a $days-day itinerary for $destination.
    Traveler interests: ${interests.join(', ')}
    Include:
    - Daily activities with times
    - Restaurant recommendations
    - Transportation tips
    - Budget estimates
  ''';
  
  final response = await _model.generateContent([
    Content.text(prompt)
  ]);
  
  return response.text ?? '';
}
```

### Expense Categorization

```dart theme={null}
Future<String> categorizeExpense({
  required String description,
  required double amount,
}) async {
  final prompt = '''
    Categorize this expense:
    Description: $description
    Amount: \$$amount
    
    Return one of: Food, Transport, Accommodation, 
    Entertainment, Shopping, Other
  ''';
  
  final response = await _model.generateContent([
    Content.text(prompt)
  ]);
  
  return response.text ?? 'Other';
}
```

### Smart Suggestions

```dart theme={null}
Future<List<String>> getSuggestions({
  required String context,
  required String userQuery,
}) async {
  final prompt = '''
    Context: $context
    User Query: $userQuery
    
    Provide 3 relevant suggestions.
  ''';
  
  final response = await _model.generateContent([
    Content.text(prompt)
  ]);
  
  return parseListResponse(response.text);
}
```

## Advanced Features

### Multi-modal Input

```dart theme={null}
// Analyze receipt image
Future<ExpenseData> analyzeReceipt(Uint8List imageBytes) async {
  final response = await _model.generateContent([
    Content.multi([
      TextPart('Extract expense details from this receipt:'),
      DataPart('image/jpeg', imageBytes),
    ])
  ]);
  
  return parseExpenseData(response.text);
}
```

### Streaming Responses

```dart theme={null}
Stream<String> streamResponse(String prompt) async* {
  final response = _model.generateContentStream([
    Content.text(prompt)
  ]);
  
  await for (final chunk in response) {
    yield chunk.text ?? '';
  }
}
```

## Rate Limiting

<Warning>
  Gemini Pro has rate limits: 60 requests per minute
</Warning>

```dart theme={null}
class RateLimiter {
  final _requestTimes = <DateTime>[];
  final _maxRequests = 60;
  final _timeWindow = Duration(minutes: 1);
  
  Future<void> checkLimit() async {
    final now = DateTime.now();
    _requestTimes.removeWhere(
      (time) => now.difference(time) > _timeWindow
    );
    
    if (_requestTimes.length >= _maxRequests) {
      final oldestRequest = _requestTimes.first;
      final waitTime = _timeWindow - now.difference(oldestRequest);
      await Future.delayed(waitTime);
    }
    
    _requestTimes.add(now);
  }
}
```

## Error Handling

```dart theme={null}
try {
  final response = await _model.generateContent([...]);
  return response.text;
} on GenerativeAIException catch (e) {
  // Handle API errors
  logger.error('Gemini API error: $e');
  return fallbackResponse();
} catch (e) {
  // Handle other errors
  logger.error('Unexpected error: $e');
  rethrow;
}
```

## Best Practices

1. **Cache responses** when appropriate
2. **Implement retry logic** with exponential backoff
3. **Use streaming** for long responses
4. **Validate and sanitize** AI outputs
5. **Monitor token usage** to control costs
6. **Provide fallbacks** for API failures


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.