Building an AI-Powered “Rizz” App: A Deep Dive with Flutter, Go, and OpenAI

rizz_app/
├── lib/            # Flutter Frontend
│   ├── main.dart          # App Entry Point
│   ├── screens/           # UI Screens
│   │   └── home_screen.dart # Main screen with input and advice
│   └── services/        # Abstraction for API communication
│       └── api_service.dart # Handles requests to the Go backend
├── backend/          # Go Backend
│   ├── main.go          # Server entry point and routing
│   └── data/            # Data layer (in-memory for this example)
│        └── datastore.go  # OpenAI interaction and (placeholder for) data storage
├── pubspec.yaml       # Flutter Dependencies
└── README.md

dependencies:
  flutter:
    sdk: flutter
  http: ^1.1.0      # For making HTTP requests
  image_picker: ^1.0.4   # For image selection
  image_cropper: ^5.0.0  # For image cropping
  cupertino_icons: ^1.0.2
  path_provider: ^2.1.1

dev_dependencies:
  flutter_test:
    sdk: flutter
  flutter_lints: ^2.0.0

import 'package:flutter/material.dart';
import 'package:rizz_app/screens/home_screen.dart';

void main() {
  runApp(const RizzApp());
}

class RizzApp extends StatelessWidget {
  const RizzApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Rizz App',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: const HomeScreen(),
    );
  }
}

import 'dart:io';
import 'package:flutter/material.dart';
import 'package:image_picker/image_picker.dart';
import 'package:image_cropper/image_cropper.dart';
import 'package:path_provider/path_provider.dart';
import 'package:rizz_app/services/api_service.dart';

class HomeScreen extends StatefulWidget {
  const HomeScreen({super.key});

  @override
  _HomeScreenState createState() => _HomeScreenState();
}

class _HomeScreenState extends State<HomeScreen> {
  final _textController = TextEditingController();
  String _advice = '';
  bool _isLoading = false;
  File? _imageFile;

  Future<void> _pickImage(ImageSource source) async {
    final pickedFile = await ImagePicker().pickImage(source: source);
    if (pickedFile != null) {
      _cropImage(File(pickedFile.path));
    }
  }
    Future<void> _cropImage(File imageFile) async {
      final directory = await getApplicationDocumentsDirectory();
      final name =  DateTime.now().millisecondsSinceEpoch.toString();
      final path = '${directory.path}/$name.jpg';
    CroppedFile? croppedFile = await ImageCropper().cropImage(
      sourcePath: imageFile.path,
      aspectRatioPresets: [
        CropAspectRatioPreset.square,
        CropAspectRatioPreset.ratio3x2,
        CropAspectRatioPreset.original,
        CropAspectRatioPreset.ratio4x3,
        CropAspectRatioPreset.ratio16x9
      ],
      uiSettings: [
        AndroidUiSettings(
            toolbarTitle: 'Cropper',
            toolbarColor: Colors.deepOrange,
            toolbarWidgetColor: Colors.white,
            initAspectRatio: CropAspectRatioPreset.original,
            lockAspectRatio: false),
        IOSUiSettings(
          title: 'Cropper',
        ),
      ],
    );
    if (croppedFile != null) {
      setState(() {
        _imageFile = File(croppedFile.path);
        //Save Image
        _imageFile?.copy(path);
      });
    }
  }

  void _getAdvice() async {
    if (_textController.text.isEmpty && _imageFile == null) {
      //Simple validation
      return;
    }
    setState(() {
      _isLoading = true;
      _advice = '';
    });

    String textInput = _textController.text;
      String? imagePath;
    if (_imageFile != null) {
      // Get the image file path
      imagePath = _imageFile!.path;
    }

    try {
      final advice = await ApiService.getAdvice(textInput, imagePath);
      setState(() {
        _advice = advice;
      });
    } catch (e) {
      setState(() {
        _advice = 'Error: Could not get advice. $e';
      });
    } finally {
      setState(() {
        _isLoading = false;
      });
    }
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Rizz Advisor'),
      ),
      body: Padding(
        padding: const EdgeInsets.all(16.0),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.stretch,
          children: [
            TextField(
              controller: _textController,
              decoration: const InputDecoration(
                labelText: 'Enter text message(s)',
                border: OutlineInputBorder(),
              ),
              maxLines: 3,
            ),
            const SizedBox(height: 10),
             Row(
              mainAxisAlignment: MainAxisAlignment.spaceEvenly,
              children: <Widget>[
                ElevatedButton.icon(
                  onPressed: () => _pickImage(ImageSource.camera),
                  icon: const Icon(Icons.camera_alt),
                  label: const Text('Camera'),
                ),
                ElevatedButton.icon(
                  onPressed: () => _pickImage(ImageSource.gallery),
                  icon: const Icon(Icons.photo_library),
                  label: const Text('Gallery'),
                ),
              ],
            ),
             if (_imageFile != null) ...[
              const SizedBox(height: 10),
              Image.file(_imageFile!), // Display the selected image.
            ],
            const SizedBox(height: 20),
            ElevatedButton(
              onPressed: _isLoading ? null : _getAdvice,
              child: _isLoading
                  ? const CircularProgressIndicator()
                  : const Text('Get Advice'),
            ),
            const SizedBox(height: 20),
            Expanded(
              child: SingleChildScrollView(
                child: Text(
                  _advice,
                  style: const TextStyle(fontSize: 16),
                ),
              ),
            ),
          ],
        ),
      ),
    );
  }

  @override
  void dispose() {
    _textController.dispose();
    super.dispose();
  }
}

import 'dart:convert';
import 'dart:io';
import 'package:http/http.dart' as http;

class ApiService {
  static const String _baseUrl = 'http://localhost:8080'; //  Go backend URL

  static Future<String> getAdvice(String textInput, String? imagePath) async {
    final url = Uri.parse('$_baseUrl/advice');
    final Map<String, String> headers = {
      'Content-Type': 'application/json',
    };
    // Prepare the body, including the image path if available
    final body = jsonEncode({
      'text': textInput,
      'imagePath': imagePath, // This will be null if no image is selected
    });

    final response = await http.post(url, headers: headers, body: body);

    if (response.statusCode == 200) {
      final Map<String, dynamic> data = json.decode(response.body);
      return data['advice'];
    } else {
      throw Exception('Failed to get advice: ${response.statusCode}');
    }
  }
}

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "log"
    "net/http"
    "os"
    "strings"

    "rizz_app/data"

    "github.com/joho/godotenv"
)

// RequestData defines the structure of the incoming JSON request.
type RequestData struct {
    Text      string `json:"text"`
    ImagePath string `json:"imagePath"` // Path to the image (if provided)
}

// ResponseData defines the structure of the JSON response.
type ResponseData struct {
    Advice string `json:"advice"`
}

// adviceHandler handles requests to the /advice endpoint.
func adviceHandler(w http.ResponseWriter, r *http.Request) {
    // Enable CORS for local development.  Remove or configure properly for production.
    w.Header().Set("Access-Control-Allow-Origin", "*")
    w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
    // Handle preflight requests for CORS.
    if r.Method == "OPTIONS" {
        w.WriteHeader(http.StatusOK)
        return
    }

    // Decode the JSON request body.
    var requestData RequestData
    decoder := json.NewDecoder(r.Body)
    if err := decoder.Decode(&requestData); err != nil {
        http.Error(w, "Invalid request body", http.StatusBadRequest)
        return
    }

    // Process the image if a path is provided.
    var combinedInput string
    if requestData.ImagePath != "" {
        //Correct the Image Path
        imagePath := strings.ReplaceAll(requestData.ImagePath, "\\", "/")

        file, err := os.Open(imagePath)
        if err != nil {
            http.Error(w, "Failed to open image file", http.StatusInternalServerError)
            return
        }
        defer file.Close()
        imageBytes, err := io.ReadAll(file)
        if err != nil {
            http.Error(w, "Failed to read the image", http.StatusInternalServerError)
            return
        }

        // Convert image bytes to base64 string (or handle as needed)
        // base64Image := base64.StdEncoding.EncodeToString(imageBytes)
        imageData := string(imageBytes)

        // Combine image data with text input
        combinedInput = fmt.Sprintf("Image Data Length: %d, Text: %s", len(imageData), requestData.Text)
    } else {
        combinedInput = requestData.Text
    }

    // Get advice from the OpenAI API (using our data layer).
    advice, err := data.GetOpenAIResponse(combinedInput)
    if err != nil {
        http.Error(w, "Failed to get AI advice", http.StatusInternalServerError)
        return
    }

    // Construct the response and send it back as JSON.
    responseData := ResponseData{Advice: advice}
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(responseData)
}

func main() {
    // Load environment variables from a .env file.
    err := godotenv.Load()
    if err != nil {
        log.Fatal("Error loading .env file")
    }
    // Check if the required environment variable is set
    openAIKey := os.Getenv("OPENAI_API_KEY")
    if openAIKey == "" {
        log.Fatal("OPENAI_API_KEY environment variable not set")
    }
    // Initialize the data store with the OpenAI API key
    data.InitDataStore(openAIKey)

    // Set up the HTTP route handler.
    http.HandleFunc("/advice", adviceHandler)

    // Start the server.
    fmt.Println("Server listening on port 8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

package data

import (
    "context"
    "fmt"
    "log"
    "strings"

    "github.com/sashabaranov/go-openai"
)

var client *openai.Client

// InitDataStore initializes the data store with the OpenAI API key.
func InitDataStore(apiKey string) {
    client = openai.NewClient(apiKey)
}
// GetOpenAIResponse gets advice from the OpenAI API based on the input.
func GetOpenAIResponse(input string) (string, error) {
    // Check if the client is initialized
    if client == nil {
        log.Fatal("OpenAI client not initialized")
    }
    prompt := fmt.Sprintf("Give dating advice based on this context, make sure it is only a sentence or two: %s", input)
    resp, err := client.CreateChatCompletion(
        context.Background(),
        openai.ChatCompletionRequest{
            Model: openai.GPT3Dot5Turbo,
            Messages: []openai.ChatCompletionMessage{
                {
                    Role:    openai.ChatMessageRoleUser,
                    Content: prompt,
                },
            },
        },
    )

    if err != nil {
        fmt.Printf("ChatCompletion error: %v\n", err)
        return "", err
    }
    //Remove new line characters
    advice := strings.ReplaceAll(resp.Choices[0].Message.Content, "\n", "")

    return advice, nil
}

OPENAI_API_KEY=YOUR_ACTUAL_OPENAI_API_KEY