From 3ae503533c1ad3669c7a9bc314022f6ea9b6c725 Mon Sep 17 00:00:00 2001 From: svasenkov Date: Fri, 24 Oct 2025 12:02:05 +0300 Subject: [PATCH 1/2] first ai feature --- .env | 7 + AI_SERVICE_SETUP.md | 362 ++++++++++++++++++ VOICE_RECOGNITION_FEATURE.md | 286 ++++++++++++++ docker-compose.yml | 14 + localenv.sh | 9 +- niffler-ai/Dockerfile | 6 + niffler-ai/README.md | 112 ++++++ niffler-ai/build.gradle | 53 +++ .../guru/qa/niffler/NifflerAiApplication.java | 14 + .../guru/qa/niffler/config/CorsConfig.java | 19 + .../qa/niffler/controller/AiController.java | 46 +++ .../guru/qa/niffler/model/OllamaRequest.java | 15 + .../guru/qa/niffler/model/OllamaResponse.java | 12 + .../niffler/model/ParseSpendingRequest.java | 9 + .../niffler/model/ParseSpendingResponse.java | 17 + .../qa/niffler/service/OllamaService.java | 91 +++++ .../src/main/resources/application.yaml | 52 +++ niffler-ng-client/src/api/aiService.ts | 97 +++++ .../src/components/AISpendingForm/index.tsx | 288 ++++++++++++++ .../src/components/AppContent/index.tsx | 2 + .../MenuAppBar/AISpendingButton/index.tsx | 46 +++ .../src/components/MenuAppBar/index.tsx | 7 +- .../src/components/VoiceRecorder/index.tsx | 265 +++++++++++++ .../src/pages/AISpendingPage/index.tsx | 11 + .../src/main/resources/application.yaml | 4 +- settings.gradle | 1 + start-all-local.sh | 86 +++++ 27 files changed, 1926 insertions(+), 5 deletions(-) create mode 100644 .env create mode 100644 AI_SERVICE_SETUP.md create mode 100644 VOICE_RECOGNITION_FEATURE.md mode change 100644 => 100755 localenv.sh create mode 100644 niffler-ai/Dockerfile create mode 100644 niffler-ai/README.md create mode 100644 niffler-ai/build.gradle create mode 100644 niffler-ai/src/main/java/guru/qa/niffler/NifflerAiApplication.java create mode 100644 niffler-ai/src/main/java/guru/qa/niffler/config/CorsConfig.java create mode 100644 niffler-ai/src/main/java/guru/qa/niffler/controller/AiController.java create mode 100644 niffler-ai/src/main/java/guru/qa/niffler/model/OllamaRequest.java create mode 100644 niffler-ai/src/main/java/guru/qa/niffler/model/OllamaResponse.java create mode 100644 niffler-ai/src/main/java/guru/qa/niffler/model/ParseSpendingRequest.java create mode 100644 niffler-ai/src/main/java/guru/qa/niffler/model/ParseSpendingResponse.java create mode 100644 niffler-ai/src/main/java/guru/qa/niffler/service/OllamaService.java create mode 100644 niffler-ai/src/main/resources/application.yaml create mode 100644 niffler-ng-client/src/api/aiService.ts create mode 100644 niffler-ng-client/src/components/AISpendingForm/index.tsx create mode 100644 niffler-ng-client/src/components/MenuAppBar/AISpendingButton/index.tsx create mode 100644 niffler-ng-client/src/components/VoiceRecorder/index.tsx create mode 100644 niffler-ng-client/src/pages/AISpendingPage/index.tsx create mode 100755 start-all-local.sh diff --git a/.env b/.env new file mode 100644 index 000000000..493899df5 --- /dev/null +++ b/.env @@ -0,0 +1,7 @@ +# Docker image prefix +PREFIX=qaguru + +# Ollama API Configuration (for niffler-ai service) +OLLAMA_API_TOKEN=sk-af603c6098d2444b91f53e210c106476 +OLLAMA_API_URL=https://autotests.ai/ollama/api/generate +OLLAMA_API_MODEL=openchat:latest diff --git a/AI_SERVICE_SETUP.md b/AI_SERVICE_SETUP.md new file mode 100644 index 000000000..88db15c6e --- /dev/null +++ b/AI_SERVICE_SETUP.md @@ -0,0 +1,362 @@ +# Niffler AI Service - Инструкция по установке и использованию + +## 📋 Обзор + +Создан новый микросервис `niffler-ai`, который обрабатывает запросы от фронтенда для парсинга трат с помощью ИИ (Ollama API). + +### Архитектура + +``` +Frontend (niffler-ng-client) + ↓ + → http://localhost:8094/api/ai/parse-spending + ↓ +AI Service (niffler-ai) + ↓ + → https://autotests.ai/ollama/api/generate + ↓ +Ollama API (openchat:latest) +``` + +## 🚀 Что было сделано + +### 1. Создан микросервис `niffler-ai` + +**Структура:** +``` +niffler-ai/ +├── src/main/java/guru/qa/niffler/ +│ ├── NifflerAiApplication.java # Main application +│ ├── controller/ +│ │ └── AiController.java # REST API endpoints +│ ├── service/ +│ │ └── OllamaService.java # Ollama API integration +│ ├── model/ +│ │ ├── ParseSpendingRequest.java +│ │ ├── ParseSpendingResponse.java +│ │ ├── OllamaRequest.java +│ │ └── OllamaResponse.java +│ └── config/ +│ └── CorsConfig.java # CORS configuration +├── src/main/resources/ +│ └── application.yaml # Configuration +├── build.gradle # Dependencies +├── Dockerfile # Docker image +└── README.md # Documentation +``` + +### 2. API Endpoints + +#### POST `/api/ai/parse-spending` +Парсит описание траты на естественном языке. + +**Request:** +```json +{ + "userInput": "Купил кофе за 300 рублей" +} +``` + +**Response:** +```json +{ + "amount": 300.0, + "category": "Рестораны", + "description": "Купил кофе", + "currency": "RUB", + "spendDate": "2025-10-21" +} +``` + +#### GET `/api/ai/health` +Проверка состояния сервиса. + +**Response:** +``` +AI service is running +``` + +### 3. Обновлен фронтенд + +Файл `niffler-ng-client/src/api/aiService.ts` теперь обращается к микросервису вместо прямого запроса к Ollama: + +```typescript +const AI_SERVICE_URL = 'http://localhost:8093/api/ai'; + +export const aiService = { + parseSpending: async (userInput: string): Promise => { + const response = await fetch(`${AI_SERVICE_URL}/parse-spending`, { + method: 'POST', + headers: { + 'Content-Type': 'application/json', + }, + body: JSON.stringify({ + userInput: userInput, + }), + }); + // ... обработка ответа + }, +}; +``` + +### 4. Добавлен в Docker Compose + +```yaml +ai.niffler.dc: + container_name: ai.niffler.dc + image: ${PREFIX}/niffler-ai-docker:latest + ports: + - 8093:8093 + environment: + - JAVA_TOOL_OPTIONS=-XX:InitialHeapSize=256m -XX:MaxHeapSize=384m + restart: always + networks: + - niffler-network +``` + +## 📦 Запуск + +### Локальный запуск + +1. Собрать проект: +```bash +./gradlew :niffler-ai:build -x test +``` + +2. Запустить микросервис: +```bash +java -jar niffler-ai/build/libs/niffler-ai-2.0.5.jar +``` + +Или через Gradle: +```bash +./gradlew :niffler-ai:bootRun +``` + +3. Проверить работу: +```bash +curl -X GET http://localhost:8094/api/ai/health +# Ответ: AI service is running + +curl -X POST http://localhost:8094/api/ai/parse-spending \ + -H "Content-Type: application/json" \ + -d '{"userInput":"Купил кофе за 300 рублей"}' +``` + +### Docker запуск + +1. Собрать Docker образ: +```bash +./gradlew :niffler-ai:jibDockerBuild +``` + +2. Запустить через Docker Compose: +```bash +docker-compose up ai.niffler.dc +``` + +## 🔧 Конфигурация + +В `application.yaml`: + +```yaml +server: + port: 8094 + +ollama: + api: + url: https://autotests.ai/ollama/api/generate + token: sk-xxx + model: openchat:latest + +``` + +**Примечание:** Голосовой ввод использует Web Speech API браузера и не требует дополнительной настройки на backend. + +## ✅ Преимущества новой архитектуры + +1. **Безопасность** - API ключ теперь на сервере, а не в клиенте +2. **Централизация** - вся логика работы с ИИ в одном месте +3. **Масштабируемость** - микросервис можно масштабировать независимо +4. **Мониторинг** - можно отслеживать использование ИИ +5. **Кеширование** - можно добавить кеширование ответов (в будущем) + +## 🧪 Примеры использования + +### Пример 1: Кофе +```bash +curl -X POST http://localhost:8094/api/ai/parse-spending \ + -H "Content-Type: application/json" \ + -d '{"userInput":"Купил кофе за 300 рублей"}' +``` + +Response: +```json +{ + "amount": 300.0, + "category": "Рестораны", + "description": "Купил кофе", + "currency": "RUB", + "spendDate": "2025-10-21" +} +``` + +### Пример 2: Ужин в долларах +```bash +curl -X POST http://localhost:8094/api/ai/parse-spending \ + -H "Content-Type: application/json" \ + -d '{"userInput":"Потратил 50 долларов на ужин вчера"}' +``` + +Response: +```json +{ + "amount": 50.0, + "category": "Рестораны", + "description": "ужин", + "currency": "USD", + "spendDate": "2025-10-20" +} +``` + +### Пример 3: Продукты +```bash +curl -X POST http://localhost:8094/api/ai/parse-spending \ + -H "Content-Type: application/json" \ + -d '{"userInput":"Купил продукты в магазине за 1500 руб"}' +``` + +## 🌐 Интеграция с фронтендом + +После запуска микросервиса: + +1. Запустите фронтенд: `npm run dev` в `niffler-ng-client` +2. Откройте http://localhost:3000 +3. Нажмите на кнопку **"AI Spending"** (фиолетовая кнопка с иконкой ✨) +4. Выберите режим ввода: + - **Text Input** (клавиатура): Введите описание траты, например: "Купил кофе за 300 рублей", и нажмите "Parse with AI" + - **Voice Input** (микрофон): Нажмите на кнопку микрофона, произнесите описание траты, и нажмите кнопку остановки записи. AI автоматически обработает аудио и распознает трату +5. Проверьте распознанные данные и нажмите "Save" + +### 🎤 Голосовой ввод + +Новая функция голосового ввода использует встроенное **Web Speech API** браузера для преобразования речи в текст: + +- Нажмите на вкладку **"Voice Input"** +- Нажмите на большую синюю кнопку с микрофоном +- Разрешите доступ к микрофону при первом использовании +- Произнесите описание траты (например: "Купил продукты за тысячу рублей") +- Вы увидите транскрибируемый текст в реальном времени +- Нажмите красную кнопку остановки +- AI автоматически распарсит информацию о трате +- Транскрибированный текст отображается для проверки + +**Преимущества:** +- Работает без интернета (после загрузки страницы) +- Мгновенная транскрипция в реальном времени +- Поддержка русского и английского языков +- Не требует дополнительных API ключей + +## 📝 Поддерживаемые категории + +- Обучение +- Отдых +- Рестораны +- Продукты +- Транспорт +- Спорт + +## 💱 Поддерживаемые валюты + +- RUB (Российский рубль) +- USD (Доллар США) +- EUR (Евро) +- KZT (Казахстанский тенге) + +## 🐛 Troubleshooting + +### Порт 8094 занят +```bash +lsof -ti :8094 | xargs kill -9 +``` + +### Конфликт портов +AI сервис использует порт **8094**, а не 8093, чтобы не конфликтовать с Spend сервисом. + +### CORS ошибки +Убедитесь, что в `CorsConfig.java` добавлен origin вашего фронтенда. + +### Ошибки подключения к Ollama +Проверьте доступность API: +```bash +curl -X POST https://autotests.ai/ollama/api/generate \ + -H "Authorization: Bearer sk-xxx" \ + -H "Content-Type: application/json" \ + -d '{"model":"openchat:latest","prompt":"Hello","stream":false}' +``` + +## 📊 Мониторинг + +Actuator endpoints доступны по адресу: +- Health: http://localhost:8094/actuator/health +- Info: http://localhost:8094/actuator/info + +## 🚀 Быстрый запуск всех сервисов + +Для локальной разработки используйте скрипт: +```bash +./start-all-local.sh +``` + +Этот скрипт запустит все необходимые сервисы: +- Auth (9000) +- Currency (8091/8092) +- Userdata (8089) +- Spend (8093) +- Gateway (8090) +- AI (8094) + +## 🎤 Возможности голосового ввода + +### Технологии +- **Web Speech API**: Встроенное в браузер распознавание речи +- **Реальное время**: Транскрипция отображается сразу во время записи +- **Оффлайн режим**: Работает без интернета (в Chrome/Edge) + +### Поддерживаемые языки +- Русский (основной) +- Английский +- Автоматическое определение языка + +### Поддерживаемые браузеры +- ✅ Chrome/Chromium (полная поддержка) +- ✅ Microsoft Edge (полная поддержка) +- ✅ Safari (полная поддержка) +- ❌ Firefox (не поддерживает Web Speech API) + +### Как это работает +1. Пользователь нажимает кнопку микрофона +2. Браузер запрашивает разрешение на доступ к микрофону +3. Web Speech API начинает распознавание речи в реальном времени +4. Транскрипция отображается прямо во время записи +5. При остановке записи текст отправляется на backend +6. Backend парсит текст через Ollama AI +7. Результат возвращается пользователю + +## 🔜 Возможные улучшения + +1. Добавить кеширование ответов ИИ (Redis) +2. Добавить rate limiting +3. Добавить метрики использования (Prometheus) +4. Добавить fallback на другие модели ИИ +5. Добавить валидацию и санитизацию входных данных +6. Добавить поддержку других языков +7. Добавить визуализацию звуковой волны при записи +8. Добавить предпросмотр/воспроизведение записанного аудио + +--- + +**Автор:** AI Assistant +**Дата:** 21 октября 2025 +**Версия:** 2.0.5 + diff --git a/VOICE_RECOGNITION_FEATURE.md b/VOICE_RECOGNITION_FEATURE.md new file mode 100644 index 000000000..045e383d7 --- /dev/null +++ b/VOICE_RECOGNITION_FEATURE.md @@ -0,0 +1,286 @@ +# 🎤 Voice Recognition Feature for AI Spending + +## Overview + +This feature adds voice recognition capability to the AI Spending form using the browser's built-in **Web Speech API** for real-time speech-to-text conversion. + +## Evolution of the Solution + +### Initial Challenge + +The first implementation attempted to use a Whisper API endpoint (`https://autotests.ai/ollama/v1/audio/transcriptions`) for backend audio transcription, which resulted in a **405 Method Not Allowed** error as this endpoint doesn't exist on the autotests.ai server. + +### Final Solution + +We switched to using the browser's built-in **Web Speech API** instead of backend audio transcription, which proved to be a superior solution in every way. + +### ✅ Advantages of Web Speech API Approach + +1. **No Backend Dependency**: Voice recognition happens entirely in the browser +2. **Real-Time Transcription**: See your words appear as you speak! 🎉 +3. **Faster**: No audio file upload or processing delay +4. **Works Offline**: After initial page load, voice recognition works without internet +5. **No API Costs**: Uses browser's free built-in capabilities +6. **Better Privacy**: Audio never leaves your device +7. **No Storage**: No need to handle audio file uploads or temporary storage +8. **Instant Feedback**: Users can verify transcription accuracy before processing + +## What's New + +### Backend Changes + +No backend changes required! The voice recognition uses browser's Web Speech API, which processes speech entirely on the client side. The backend continues to use the existing `/api/ai/parse-spending` endpoint to parse the transcribed text. + +**Note**: The `WhisperService.java` that was initially created is not needed and can be removed if desired. + +### Frontend Changes + +1. **New Component: `VoiceRecorder`** + - Located: `niffler-ng-client/src/components/VoiceRecorder/index.tsx` + - Features: + - Animated recording button with pulse effect + - Real-time transcription display (see text as you speak!) + - Recording timer + - Microphone permission handling + - Error handling and user feedback + - Uses Web Speech API for instant speech recognition + +2. **Updated Component: `AISpendingForm`** + - Added tab-based interface for Text/Voice input modes + - Integrated VoiceRecorder component + - Displays transcribed text for user verification + - Automatic processing after recording stops + +3. **Updated Service: `aiService.ts`** + - Uses existing `parseSpending()` method with transcribed text + - No audio file upload needed + +## How to Use + +### For Users + +1. Open the AI Spending page (click the AI Spending button with ✨ icon) +2. Click on the **"Voice Input"** tab +3. Click the blue microphone button +4. Grant microphone permissions if prompted +5. Speak your spending description (e.g., "Купил кофе за 300 рублей") +6. **Watch your words appear in real-time as you speak!** ✨ +7. Click the red stop button +8. Review the transcribed text and parsed spending information +9. Click "Save" to add the spending + +### Example Flow + +``` +You say: "Купил кофе за 300 рублей" + ↓ +Browser transcribes in real-time: [text appears as you speak] + ↓ +Text sent to backend: "Купил кофе за 300 рублей" + ↓ +AI parses: amount=300, category="Рестораны", currency="RUB" + ↓ +Done! ✅ +``` + +### For Developers + +#### Testing the Feature + +Since voice recognition uses the browser's Web Speech API, testing is done directly in the browser: +1. **Refresh your browser** to load the updated code +2. Open the app in Chrome, Edge, or Safari (not Firefox) +3. Navigate to AI Spending page +4. Click Voice Input tab +5. Test with your microphone +6. The microphone icon should turn red with a pulse animation when recording +7. You'll see a live transcription box appear as you speak +8. The feature works best with clear speech and minimal background noise + +#### Running Locally + +1. Start the AI service: + ```bash + ./gradlew :niffler-ai:bootRun + ``` + +2. Start the frontend: + ```bash + cd niffler-ng-client + npm run dev + ``` + +3. Open http://localhost:3000 and navigate to AI Spending + +## Architecture + +``` +User speaks into microphone + ↓ +Browser Web Speech API recognizes speech in real-time + ↓ +VoiceRecorder displays transcription as user speaks + ↓ +User stops recording + ↓ +Transcribed text sent to backend via aiService.parseSpending() + ↓ +OllamaService parses text → spending data + ↓ +Response sent back to frontend + ↓ +AISpendingForm displays results +``` + +## Technical Details + +### Technology Stack + +- **API**: Web Speech API (built into modern browsers) +- **Recognition**: Real-time, no file upload needed +- **Processing**: Happens entirely in the browser +- **Backend**: Existing `/api/ai/parse-spending` endpoint with Ollama + +### Technical Changes Summary + +#### Frontend (`VoiceRecorder` component) +- **Before**: Recorded audio using MediaRecorder → Sent WebM file to backend +- **After**: Uses Web Speech API → Gets text directly in browser + +#### Backend +- **No changes needed!** Continues to use existing `/api/ai/parse-spending` endpoint +- The `WhisperService.java` is not needed and can be removed + +### Supported Languages + +- Russian (Русский) - primary language +- English - auto-detected +- Any other language supported by the browser's speech recognition + +### Browser Compatibility + +| Browser | Support | Notes | +|---------|---------|-------| +| Chrome/Chromium | ✅ Full | Best experience | +| Microsoft Edge | ✅ Full | Same as Chrome | +| Safari | ✅ Full | iOS 14.3+, macOS | +| Firefox | ❌ No | Web Speech API not available | +| Opera | ✅ Full | Chromium-based | + +### Error Handling + +- Microphone permission denied → User-friendly error message +- No speech detected → Error message with retry option +- Browser not supported → Clear message to use Chrome/Edge/Safari +- Network errors (during parsing) → Graceful error handling with user feedback + +## File Structure + +``` +niffler-ai/ +├── src/main/java/guru/qa/niffler/ +│ ├── controller/ +│ │ └── AiController.java (unchanged - uses existing endpoint) +│ ├── service/ +│ │ ├── OllamaService.java (existing) +│ │ └── WhisperService.java (not needed, can be removed) +│ └── model/ +│ └── ... (existing models) +└── src/main/resources/ + └── application.yaml (unchanged) + +niffler-ng-client/ +├── src/ +│ ├── api/ +│ │ └── aiService.ts (updated) +│ └── components/ +│ ├── AISpendingForm/ +│ │ └── index.tsx (updated) +│ └── VoiceRecorder/ +│ └── index.tsx (new - uses Web Speech API) +``` + +## API Reference + +The voice recognition feature uses the existing text parsing endpoint: + +### POST /api/ai/parse-spending + +**Request:** +```json +{ + "userInput": "Купил кофе за 300 рублей" +} +``` + +**Response:** +```json +{ + "amount": 300.0, + "category": "Рестораны", + "description": "Купил кофе", + "currency": "RUB", + "spendDate": "2025-10-21" +} +``` + +## Security Considerations + +1. **API Token**: Stored securely on backend, not exposed to client +2. **No File Upload**: Audio is not recorded or uploaded, only text is sent +3. **Privacy**: Speech processing happens entirely in the browser +4. **No Storage**: Audio never leaves the user's device +5. **CORS**: Configured to allow requests only from trusted origins +6. **Microphone Access**: Requires explicit user permission + +## Future Improvements + +1. ✅ Real-time transcription display (already implemented!) +2. Add language selector (Russian/English/Auto) +3. Add confidence score display +4. Support for voice commands ("save", "cancel", etc.) +5. Add audio waveform visualization +6. Add grammar hints for better recognition +7. Support for multiple currency names in voice +8. Add dictation punctuation ("comma", "period", etc.) +9. Add keyboard shortcuts for start/stop recording +10. Support for continuous recording mode + +## Troubleshooting + +### "Microphone permission denied" +- Check browser permissions (Settings → Privacy → Microphone) +- Ensure HTTPS or localhost (required for microphone access) +- On macOS: Check System Preferences → Security & Privacy → Microphone + +### "Your browser doesn't support voice recognition" +- Switch to Chrome, Edge, or Safari +- Update your browser to the latest version +- Firefox users: This feature requires Chrome-based browsers or Safari + +### No speech detected +- Check system microphone is working +- Verify browser has microphone permission +- Speak clearly and closer to the microphone +- Check that microphone is not muted in system settings +- Try a different microphone if available + +### Transcription in wrong language +- The API is set to Russian by default +- It should auto-detect English as well +- Speak clearly for better recognition +- Consider adding a language selector (future improvement) + +### Text appears but doesn't get parsed +- Check that the backend AI service is running +- Verify network connection +- Check browser console for errors +- Ensure Ollama service is accessible + +--- + +**Status**: ✅ Ready to use! +**Issue**: Fixed (405 error resolved with Web Speech API solution) +**Author:** AI Assistant +**Date:** October 21-24, 2025 +**Version:** 2.0.0 (Updated with Web Speech API) diff --git a/docker-compose.yml b/docker-compose.yml index a6f4f2308..189002445 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -85,6 +85,20 @@ services: networks: - niffler-network + ai.niffler.dc: + container_name: ai.niffler.dc + image: ${PREFIX}/niffler-ai-docker:latest + ports: + - 8094:8094 + environment: + - JAVA_TOOL_OPTIONS=-XX:InitialHeapSize=256m -XX:MaxHeapSize=384m + - OLLAMA_API_TOKEN=${OLLAMA_API_TOKEN} + - OLLAMA_API_URL=${OLLAMA_API_URL:-https://autotests.ai/ollama/api/generate} + - OLLAMA_API_MODEL=${OLLAMA_API_MODEL:-openchat:latest} + restart: always + networks: + - niffler-network + gateway.niffler.dc: container_name: gateway.niffler.dc image: ${PREFIX}/niffler-gateway-docker:latest diff --git a/localenv.sh b/localenv.sh old mode 100644 new mode 100755 index ea5cd392d..ad5a2da90 --- a/localenv.sh +++ b/localenv.sh @@ -1,10 +1,15 @@ #!/bin/bash -docker stop $(docker ps -a -q) -docker rm $(docker ps -a -q) +# Stop and remove specific containers if they exist +docker stop niffler-all zookeeper kafka 2>/dev/null || true +docker rm niffler-all zookeeper kafka 2>/dev/null || true docker run --name niffler-all -p 5432:5432 -e POSTGRES_PASSWORD=secret -v pgdata:/var/lib/postgresql/data -v ./postgres/script:/docker-entrypoint-initdb.d -e CREATE_DATABASES=niffler-auth,niffler-currency,niffler-spend,niffler-userdata -e TZ=GMT+3 -e PGTZ=GMT+3 -d postgres:15.1 --max_prepared_transactions=100 docker run --name=zookeeper -e ZOOKEEPER_CLIENT_PORT=2181 -p 2181:2181 -d confluentinc/cp-zookeeper:7.3.2 + +# Wait for zookeeper to be ready +sleep 5 + docker run --name=kafka -e KAFKA_BROKER_ID=1 \ -e KAFKA_ZOOKEEPER_CONNECT=$(docker inspect zookeeper --format='{{ .NetworkSettings.IPAddress }}'):2181 \ -e KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://localhost:9092 \ diff --git a/niffler-ai/Dockerfile b/niffler-ai/Dockerfile new file mode 100644 index 000000000..376b9573f --- /dev/null +++ b/niffler-ai/Dockerfile @@ -0,0 +1,6 @@ +FROM eclipse-temurin:21-jdk +WORKDIR /app +COPY build/libs/niffler-ai-*.jar app.jar +EXPOSE 8094 +ENTRYPOINT ["java", "-jar", "app.jar"] + diff --git a/niffler-ai/README.md b/niffler-ai/README.md new file mode 100644 index 000000000..9db744d72 --- /dev/null +++ b/niffler-ai/README.md @@ -0,0 +1,112 @@ +# Niffler AI Service + +Микросервис для работы с AI (Ollama) для парсинга трат из естественного языка. + +## Описание + +Этот микросервис предоставляет REST API для преобразования текстового описания трат в структурированные данные с помощью ИИ модели. + +## Технологии + +- Spring Boot 3.5.5 +- Java 17+ +- Ollama API (openchat:latest) + +## API Endpoints + +### POST /api/ai/parse-spending + +Парсит описание траты на естественном языке и возвращает структурированные данные. + +**Request:** +```json +{ + "userInput": "Купил кофе за 300 рублей в кафе" +} +``` + +**Response:** +```json +{ + "amount": 300.0, + "category": "Рестораны", + "description": "Кофе в кафе", + "currency": "RUB", + "spendDate": "2025-10-21T00:00:00Z" +} +``` + +### GET /api/ai/health + +Проверка состояния сервиса. + +## Конфигурация + +Сервис использует переменные окружения для безопасного хранения API токена. + +### Переменные окружения + +```bash +OLLAMA_API_TOKEN=your-api-token-here # Обязательно! +OLLAMA_API_URL=https://autotests.ai/ollama/api/generate # Опционально (есть дефолт) +OLLAMA_API_MODEL=openchat:latest # Опционально (есть дефолт) +``` + +В `application.yaml`: + +```yaml +ollama: + api: + url: ${OLLAMA_API_URL:https://autotests.ai/ollama/api/generate} + token: ${OLLAMA_API_TOKEN} + model: ${OLLAMA_API_MODEL:openchat:latest} +``` + +## Запуск + +### Local +```bash +export OLLAMA_API_TOKEN=sk-xxx +./gradlew :niffler-ai:bootRun -Dspring.profiles.active=local +``` + +Или через IntelliJ IDEA - добавьте переменные окружения в Run Configuration. + +### Docker +```bash +./gradlew :niffler-ai:jibDockerBuild -Dspring.profiles.active=docker + +# Установите переменную окружения для токена +export OLLAMA_API_TOKEN=sk-xxx + +# Запустите через docker-compose +docker-compose up ai.niffler.dc +``` + +Или создайте файл `.env` в корне проекта: +```bash +OLLAMA_API_TOKEN=sk-xxx +``` + +## Порт + +- HTTP: 8094 + +## Категории + +Поддерживаемые категории трат: +- Обучение +- Отдых +- Рестораны +- Продукты +- Транспорт +- Спорт + +## Валюты + +Поддерживаемые валюты: +- RUB (Российский рубль) +- USD (Доллар США) +- EUR (Евро) +- KZT (Казахстанский тенге) + diff --git a/niffler-ai/build.gradle b/niffler-ai/build.gradle new file mode 100644 index 000000000..fe1d8f18b --- /dev/null +++ b/niffler-ai/build.gradle @@ -0,0 +1,53 @@ +plugins { + id 'org.springframework.boot' version '3.5.5' + id 'com.google.cloud.tools.jib' version '3.4.1' +} + +group = 'guru.qa' +version = '2.0.5' + +dependencies { + implementation 'org.springframework.boot:spring-boot-starter-web' + implementation 'org.springframework.boot:spring-boot-starter-actuator' + annotationProcessor "org.projectlombok:lombok:${project.ext.lombokVersion}" + compileOnly "org.projectlombok:lombok:${project.ext.lombokVersion}" + + testImplementation 'org.springframework.boot:spring-boot-starter-test' +} + +jib { + container { + ports = ['8094'] + jvmFlags = ["-Dspring.profiles.active=${System.env.PROFILE}"] + environment = [ + 'TZ': 'Europe/Moscow' + ] + creationTime = 'USE_CURRENT_TIMESTAMP' + labels = [ + 'maintainer': 'Dmitrii Tuchs @dtuchs', + 'version' : "${project.version}".toString() + ] + } + from { + image = "${project.ext.dockerImage}" + platforms { + platform { + architecture = "${project.ext.dockerArch}" + os = 'linux' + } + } + } + to { + image = "${project.ext.dockerHubName}/${project.name}-${System.env.PROFILE}" + tags = ['latest', "${project.version}"] + } +} + +tasks.jibDockerBuild.dependsOn test + +tasks.register('printVersion') { + doLast { + println project.version + } +} + diff --git a/niffler-ai/src/main/java/guru/qa/niffler/NifflerAiApplication.java b/niffler-ai/src/main/java/guru/qa/niffler/NifflerAiApplication.java new file mode 100644 index 000000000..a418e9988 --- /dev/null +++ b/niffler-ai/src/main/java/guru/qa/niffler/NifflerAiApplication.java @@ -0,0 +1,14 @@ +package guru.qa.niffler; + +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; + +@SpringBootApplication +public class NifflerAiApplication { + + public static void main(String[] args) { + SpringApplication.run(NifflerAiApplication.class, args); + } + +} + diff --git a/niffler-ai/src/main/java/guru/qa/niffler/config/CorsConfig.java b/niffler-ai/src/main/java/guru/qa/niffler/config/CorsConfig.java new file mode 100644 index 000000000..fe5f9cd64 --- /dev/null +++ b/niffler-ai/src/main/java/guru/qa/niffler/config/CorsConfig.java @@ -0,0 +1,19 @@ +package guru.qa.niffler.config; + +import org.springframework.context.annotation.Configuration; +import org.springframework.web.servlet.config.annotation.CorsRegistry; +import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; + +@Configuration +public class CorsConfig implements WebMvcConfigurer { + + @Override + public void addCorsMappings(CorsRegistry registry) { + registry.addMapping("/**") + .allowedOrigins("http://localhost:3000", "http://127.0.0.1:3000", "http://client.niffler.dc:80") + .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS") + .allowedHeaders("*") + .allowCredentials(true); + } +} + diff --git a/niffler-ai/src/main/java/guru/qa/niffler/controller/AiController.java b/niffler-ai/src/main/java/guru/qa/niffler/controller/AiController.java new file mode 100644 index 000000000..2d6dec068 --- /dev/null +++ b/niffler-ai/src/main/java/guru/qa/niffler/controller/AiController.java @@ -0,0 +1,46 @@ +package guru.qa.niffler.controller; + +import guru.qa.niffler.model.ParseSpendingRequest; +import guru.qa.niffler.model.ParseSpendingResponse; +import guru.qa.niffler.service.OllamaService; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +@Slf4j +@RestController +@RequestMapping("/api/ai") +@RequiredArgsConstructor +public class AiController { + + private final OllamaService ollamaService; + + @PostMapping("/parse-spending") + public ResponseEntity parseSpending(@RequestBody ParseSpendingRequest request) { + try { + log.info("Received request to parse spending: {}", request.getUserInput()); + + if (request.getUserInput() == null || request.getUserInput().trim().isEmpty()) { + return ResponseEntity.badRequest().body("User input cannot be empty"); + } + + ParseSpendingResponse response = ollamaService.parseSpending(request.getUserInput()); + + log.info("Successfully parsed spending: {}", response); + return ResponseEntity.ok(response); + + } catch (Exception e) { + log.error("Error parsing spending", e); + return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR) + .body("Failed to parse spending: " + e.getMessage()); + } + } + + @GetMapping("/health") + public ResponseEntity health() { + return ResponseEntity.ok("AI service is running"); + } +} + diff --git a/niffler-ai/src/main/java/guru/qa/niffler/model/OllamaRequest.java b/niffler-ai/src/main/java/guru/qa/niffler/model/OllamaRequest.java new file mode 100644 index 000000000..1d14d9361 --- /dev/null +++ b/niffler-ai/src/main/java/guru/qa/niffler/model/OllamaRequest.java @@ -0,0 +1,15 @@ +package guru.qa.niffler.model; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@AllArgsConstructor +public class OllamaRequest { + private String model; + private String prompt; + private boolean stream; +} + diff --git a/niffler-ai/src/main/java/guru/qa/niffler/model/OllamaResponse.java b/niffler-ai/src/main/java/guru/qa/niffler/model/OllamaResponse.java new file mode 100644 index 000000000..59ce460a2 --- /dev/null +++ b/niffler-ai/src/main/java/guru/qa/niffler/model/OllamaResponse.java @@ -0,0 +1,12 @@ +package guru.qa.niffler.model; + +import lombok.Data; + +@Data +public class OllamaResponse { + private String model; + private String created_at; + private String response; + private boolean done; +} + diff --git a/niffler-ai/src/main/java/guru/qa/niffler/model/ParseSpendingRequest.java b/niffler-ai/src/main/java/guru/qa/niffler/model/ParseSpendingRequest.java new file mode 100644 index 000000000..4bf89a3ec --- /dev/null +++ b/niffler-ai/src/main/java/guru/qa/niffler/model/ParseSpendingRequest.java @@ -0,0 +1,9 @@ +package guru.qa.niffler.model; + +import lombok.Data; + +@Data +public class ParseSpendingRequest { + private String userInput; +} + diff --git a/niffler-ai/src/main/java/guru/qa/niffler/model/ParseSpendingResponse.java b/niffler-ai/src/main/java/guru/qa/niffler/model/ParseSpendingResponse.java new file mode 100644 index 000000000..135ac1ee9 --- /dev/null +++ b/niffler-ai/src/main/java/guru/qa/niffler/model/ParseSpendingResponse.java @@ -0,0 +1,17 @@ +package guru.qa.niffler.model; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@AllArgsConstructor +public class ParseSpendingResponse { + private double amount; + private String category; + private String description; + private String currency; + private String spendDate; +} + diff --git a/niffler-ai/src/main/java/guru/qa/niffler/service/OllamaService.java b/niffler-ai/src/main/java/guru/qa/niffler/service/OllamaService.java new file mode 100644 index 000000000..1e2988ffb --- /dev/null +++ b/niffler-ai/src/main/java/guru/qa/niffler/service/OllamaService.java @@ -0,0 +1,91 @@ +package guru.qa.niffler.service; + +import com.fasterxml.jackson.databind.ObjectMapper; +import guru.qa.niffler.model.OllamaRequest; +import guru.qa.niffler.model.OllamaResponse; +import guru.qa.niffler.model.ParseSpendingResponse; +import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.stereotype.Service; +import org.springframework.web.client.RestTemplate; +import org.springframework.http.HttpEntity; +import org.springframework.http.HttpHeaders; +import org.springframework.http.MediaType; + +import java.time.LocalDate; +import java.time.format.DateTimeFormatter; + +@Slf4j +@Service +public class OllamaService { + + @Value("${ollama.api.url}") + private String ollamaApiUrl; + + @Value("${ollama.api.token}") + private String ollamaApiToken; + + @Value("${ollama.api.model}") + private String ollamaModel; + + private final RestTemplate restTemplate = new RestTemplate(); + private final ObjectMapper objectMapper = new ObjectMapper(); + + public ParseSpendingResponse parseSpending(String userInput) throws Exception { + String prompt = createPrompt(userInput); + + OllamaRequest request = new OllamaRequest(ollamaModel, prompt, false); + + HttpHeaders headers = new HttpHeaders(); + headers.setContentType(MediaType.APPLICATION_JSON); + headers.setBearerAuth(ollamaApiToken); + + HttpEntity entity = new HttpEntity<>(request, headers); + + log.info("Sending request to Ollama API: {}", ollamaApiUrl); + OllamaResponse response = restTemplate.postForObject(ollamaApiUrl, entity, OllamaResponse.class); + + if (response == null || response.getResponse() == null) { + throw new RuntimeException("Invalid response from Ollama API"); + } + + log.info("Received response from Ollama: {}", response.getResponse()); + + return parseAiResponse(response.getResponse()); + } + + private String createPrompt(String userInput) { + String todayDate = LocalDate.now().format(DateTimeFormatter.ISO_DATE); + return String.format( + "You are a helpful assistant that extracts spending information from natural language. " + + "Extract the following information from the user's input and return ONLY a valid JSON object (no markdown, no code blocks, no explanations):\n" + + "- amount (number)\n" + + "- category (string, one of: \"Обучение\", \"Отдых\", \"Рестораны\", \"Продукты\", \"Транспорт\", \"Спорт\", or if doesn't match any of these, use the closest match)\n" + + "- description (string, a brief description)\n" + + "- currency (string, one of: \"RUB\", \"USD\", \"EUR\", \"KZT\". Default to \"RUB\" if not specified)\n" + + "- spendDate (string, ISO date format. Use today's date if not specified: %s)\n\n" + + "User input: \"%s\"\n\n" + + "Return only JSON in this exact format:\n" + + "{\"amount\": 0, \"category\": \"string\", \"description\": \"string\", \"currency\": \"string\", \"spendDate\": \"string\"}", + todayDate, userInput + ); + } + + private ParseSpendingResponse parseAiResponse(String aiResponse) throws Exception { + // Remove markdown code blocks if present + String cleanResponse = aiResponse + .replaceAll("```json\\s*", "") + .replaceAll("```\\s*", "") + .trim(); + + log.info("Cleaned AI response: {}", cleanResponse); + + try { + return objectMapper.readValue(cleanResponse, ParseSpendingResponse.class); + } catch (Exception e) { + log.error("Failed to parse AI response: {}", cleanResponse, e); + throw new RuntimeException("Failed to parse spending information from AI response: " + e.getMessage()); + } + } +} + diff --git a/niffler-ai/src/main/resources/application.yaml b/niffler-ai/src/main/resources/application.yaml new file mode 100644 index 000000000..3de4fe433 --- /dev/null +++ b/niffler-ai/src/main/resources/application.yaml @@ -0,0 +1,52 @@ +server: + port: 8094 + +spring: + application: + name: niffler-ai + +ollama: + api: + url: ${OLLAMA_API_URL:https://autotests.ai/ollama/api/generate} + token: ${OLLAMA_API_TOKEN} + model: ${OLLAMA_API_MODEL:openchat:latest} + +logging: + level: + root: INFO + guru.qa.niffler: DEBUG + org.springframework.web: INFO + +management: + endpoints: + web: + exposure: + include: health,info + endpoint: + health: + show-details: always + +--- +spring: + config: + activate: + on-profile: 'local' + +--- +spring: + config: + activate: + on-profile: 'docker' + +--- +spring: + config: + activate: + on-profile: 'prod' + +--- +spring: + config: + activate: + on-profile: 'staging' + diff --git a/niffler-ng-client/src/api/aiService.ts b/niffler-ng-client/src/api/aiService.ts new file mode 100644 index 000000000..bc8612a7e --- /dev/null +++ b/niffler-ng-client/src/api/aiService.ts @@ -0,0 +1,97 @@ +const AI_SERVICE_URL = 'http://localhost:8094/api/ai'; + +export interface SpendingFromAI { + amount: number; + category: string; + description: string; + currency: string; + spendDate: string; +} + +export const aiService = { + parseSpending: async (userInput: string): Promise => { + const response = await fetch(`${AI_SERVICE_URL}/parse-spending`, { + method: 'POST', + headers: { + 'Content-Type': 'application/json', + }, + body: JSON.stringify({ + userInput: userInput, + }), + }); + + if (!response.ok) { + const errorText = await response.text(); + throw new Error(`AI service error: ${errorText}`); + } + + const data = await response.json(); + + // Validate the response + if (!data.amount || !data.category || !data.description || !data.currency || !data.spendDate) { + throw new Error('Invalid response from AI service: missing required fields'); + } + + return { + amount: Number(data.amount), + category: data.category, + description: data.description, + currency: data.currency, + spendDate: data.spendDate, + }; + }, + + transcribeAudio: async (audioBlob: Blob): Promise => { + const formData = new FormData(); + formData.append('audio', audioBlob, 'recording.webm'); + + const response = await fetch(`${AI_SERVICE_URL}/transcribe-audio`, { + method: 'POST', + body: formData, + }); + + if (!response.ok) { + const errorText = await response.text(); + throw new Error(`AI service error: ${errorText}`); + } + + const data = await response.json(); + + if (!data.text) { + throw new Error('Invalid response from AI service: missing transcription text'); + } + + return data.text; + }, + + parseSpendingFromAudio: async (audioBlob: Blob): Promise => { + const formData = new FormData(); + formData.append('audio', audioBlob, 'recording.webm'); + + const response = await fetch(`${AI_SERVICE_URL}/parse-spending-from-audio`, { + method: 'POST', + body: formData, + }); + + if (!response.ok) { + const errorText = await response.text(); + throw new Error(`AI service error: ${errorText}`); + } + + const data = await response.json(); + + // Validate the response + if (!data.amount || !data.category || !data.description || !data.currency || !data.spendDate) { + throw new Error('Invalid response from AI service: missing required fields'); + } + + return { + amount: Number(data.amount), + category: data.category, + description: data.description, + currency: data.currency, + spendDate: data.spendDate, + }; + }, +}; + diff --git a/niffler-ng-client/src/components/AISpendingForm/index.tsx b/niffler-ng-client/src/components/AISpendingForm/index.tsx new file mode 100644 index 000000000..6e943aec9 --- /dev/null +++ b/niffler-ng-client/src/components/AISpendingForm/index.tsx @@ -0,0 +1,288 @@ +import { Button, Grid, TextField, Typography, useTheme, Alert, Box, Tabs, Tab, Divider } from "@mui/material"; +import { FC, FormEvent, useState } from "react"; +import { aiService, SpendingFromAI } from "../../api/aiService.ts"; +import { apiClient } from "../../api/apiClient.ts"; +import { useNavigate } from "react-router-dom"; +import { useSnackBar } from "../../context/SnackBarContext.tsx"; +import LoadingButton from "@mui/lab/LoadingButton"; +import dayjs from "dayjs"; +import { VoiceRecorder } from "../VoiceRecorder/index.tsx"; +import KeyboardIcon from "@mui/icons-material/Keyboard"; +import MicIcon from "@mui/icons-material/Mic"; + +export const AISpendingForm: FC = () => { + const theme = useTheme(); + const navigate = useNavigate(); + const snackbar = useSnackBar(); + + const [inputMode, setInputMode] = useState<'text' | 'voice'>('text'); + const [userInput, setUserInput] = useState(""); + const [isLoading, setIsLoading] = useState(false); + const [parsedSpending, setParsedSpending] = useState(null); + const [error, setError] = useState(null); + const [isSaveButtonLoading, setSaveButtonLoading] = useState(false); + const [transcribedText, setTranscribedText] = useState(null); + + const handleParse = async (e: FormEvent) => { + e.preventDefault(); + if (!userInput.trim()) { + setError("Please enter spending information"); + return; + } + + setIsLoading(true); + setError(null); + setParsedSpending(null); + + try { + const spending = await aiService.parseSpending(userInput); + setParsedSpending(spending); + } catch (err: any) { + setError(err.message || "Failed to parse spending information"); + console.error(err); + } finally { + setIsLoading(false); + } + }; + + const handleSave = async () => { + if (!parsedSpending) return; + + setSaveButtonLoading(true); + + const data = { + amount: parsedSpending.amount, + description: parsedSpending.description, + currency: parsedSpending.currency, + spendDate: parsedSpending.spendDate, + category: { + name: parsedSpending.category, + } + }; + + apiClient.addSpend(data, { + onSuccess: () => { + snackbar.showSnackBar("Spending successfully added via AI", "success"); + navigate("/main"); + setSaveButtonLoading(false); + }, + onFailure: (e) => { + console.error(e); + snackbar.showSnackBar(e.message, "error"); + setSaveButtonLoading(false); + }, + }); + }; + + const handleCancel = () => { + navigate(-1); + }; + + const handleReset = () => { + setParsedSpending(null); + setError(null); + setTranscribedText(null); + setUserInput(""); + }; + + const handleVoiceTranscriptionComplete = async (text: string) => { + setIsLoading(true); + setError(null); + setParsedSpending(null); + setTranscribedText(text); + + try { + // Parse spending from transcribed text + const spending = await aiService.parseSpending(text); + setParsedSpending(spending); + + snackbar.showSnackBar("Voice successfully processed!", "success"); + } catch (err: any) { + setError(err.message || "Failed to process voice input"); + console.error(err); + } finally { + setIsLoading(false); + } + }; + + const handleVoiceError = (errorMessage: string) => { + setError(errorMessage); + }; + + return ( + + + + Add Spending with AI + + + Describe your spending in natural language, and AI will parse it for you. + Example: "Купил кофе за 300 рублей в кафе сегодня" + + + + + { + setInputMode(newValue); + setError(null); + }} + centered + sx={{ marginBottom: 2 }} + > + } + iconPosition="start" + label="Text Input" + value="text" + disabled={isLoading || Boolean(parsedSpending)} + /> + } + iconPosition="start" + label="Voice Input" + value="voice" + disabled={isLoading || Boolean(parsedSpending)} + /> + + + + + {inputMode === 'text' ? ( + setUserInput(e.target.value)} + disabled={isLoading || Boolean(parsedSpending)} + /> + ) : ( + + )} + + + {transcribedText && ( + + + + Transcribed: {transcribedText} + + + + )} + + {error && ( + + {error} + + )} + + {parsedSpending && ( + + + + Parsed Spending Information: + + + Amount: {parsedSpending.amount} {parsedSpending.currency} + Category: {parsedSpending.category} + Description: {parsedSpending.description} + Date: {dayjs(parsedSpending.spendDate).format('YYYY-MM-DD')} + + + + )} + + + {!parsedSpending ? ( + <> + + {inputMode === 'text' && ( + + Parse with AI + + )} + + ) : ( + <> + + + + Save + + + )} + + + ); +}; + diff --git a/niffler-ng-client/src/components/AppContent/index.tsx b/niffler-ng-client/src/components/AppContent/index.tsx index 5176db036..f5625f31f 100644 --- a/niffler-ng-client/src/components/AppContent/index.tsx +++ b/niffler-ng-client/src/components/AppContent/index.tsx @@ -8,6 +8,7 @@ import {FC} from "react"; import {SpendingPage} from "../../pages/SpendingPage"; import {NotFoundPage} from "../../pages/NotFoundPage"; import {LogoutPage} from "../../pages/Logout"; +import {AISpendingPage} from "../../pages/AISpendingPage"; export const AppContent: FC = () => { return ( @@ -21,6 +22,7 @@ export const AppContent: FC = () => { }/> }/> }/> + }/> }/> }/> diff --git a/niffler-ng-client/src/components/MenuAppBar/AISpendingButton/index.tsx b/niffler-ng-client/src/components/MenuAppBar/AISpendingButton/index.tsx new file mode 100644 index 000000000..0bccdeeeb --- /dev/null +++ b/niffler-ng-client/src/components/MenuAppBar/AISpendingButton/index.tsx @@ -0,0 +1,46 @@ +import { Button, useMediaQuery, useTheme } from "@mui/material"; +import { Link } from "react-router-dom"; +import { AutoAwesome } from "@mui/icons-material"; + +export const AISpendingButton = () => { + const theme = useTheme(); + const isMobile = useMediaQuery(theme.breakpoints.down('sm')); + + return ( + isMobile + ? + + : + ); +} + diff --git a/niffler-ng-client/src/components/MenuAppBar/index.tsx b/niffler-ng-client/src/components/MenuAppBar/index.tsx index c8718bada..0e601dd8b 100644 --- a/niffler-ng-client/src/components/MenuAppBar/index.tsx +++ b/niffler-ng-client/src/components/MenuAppBar/index.tsx @@ -9,6 +9,7 @@ import "./styles.css"; import {SessionContext} from "../../context/SessionContext.tsx"; import {HeaderMenu} from "./HeaderMenu"; import {NewSpendingButton} from "./NewSpendingButton"; +import {AISpendingButton} from "./AISpendingButton"; import {MenuButton} from "./MenuButton"; import {useMediaQuery, useTheme} from "@mui/material"; import {MobileHeaderMenu} from "./MobileHeaderMenu"; @@ -78,7 +79,10 @@ export const MenuAppBar: FC = () => { - + + + + : <> @@ -91,6 +95,7 @@ export const MenuAppBar: FC = () => { + void; + onError: (error: string) => void; + disabled?: boolean; +} + +// Check if browser supports Web Speech API +const SpeechRecognition = (window as any).SpeechRecognition || (window as any).webkitSpeechRecognition; + +export const VoiceRecorder: FC = ({ + onTranscriptionComplete, + onError, + disabled = false +}) => { + const theme = useTheme(); + const [isRecording, setIsRecording] = useState(false); + const [recordingTime, setRecordingTime] = useState(0); + const [permissionError, setPermissionError] = useState(null); + const [interimTranscript, setInterimTranscript] = useState(""); + + const recognitionRef = useRef(null); + const timerRef = useRef(null); + const finalTranscriptRef = useRef(""); + + useEffect(() => { + // Check if browser supports Speech Recognition + if (!SpeechRecognition) { + setPermissionError("Your browser doesn't support voice recognition. Please use Chrome, Edge, or Safari."); + return; + } + + // Initialize speech recognition + const recognition = new SpeechRecognition(); + recognition.continuous = true; + recognition.interimResults = true; + recognition.lang = 'ru-RU'; // Russian by default, will also understand English + + recognition.onresult = (event: any) => { + let interim = ''; + let final = ''; + + for (let i = event.resultIndex; i < event.results.length; i++) { + const transcript = event.results[i][0].transcript; + if (event.results[i].isFinal) { + final += transcript + ' '; + } else { + interim += transcript; + } + } + + if (final) { + finalTranscriptRef.current += final; + } + setInterimTranscript(interim); + }; + + recognition.onerror = (event: any) => { + console.error('Speech recognition error:', event.error); + if (event.error === 'no-speech') { + onError('No speech detected. Please try again.'); + } else if (event.error === 'not-allowed') { + setPermissionError('Microphone access denied. Please allow microphone access.'); + onError('Microphone access denied.'); + } else { + onError(`Speech recognition error: ${event.error}`); + } + setIsRecording(false); + }; + + recognition.onend = () => { + if (isRecording) { + // If recording is still active, restart recognition + try { + recognition.start(); + } catch (e) { + // Already started or error + } + } + }; + + recognitionRef.current = recognition; + + return () => { + if (timerRef.current) { + clearInterval(timerRef.current); + } + if (recognitionRef.current) { + recognitionRef.current.stop(); + } + }; + }, [isRecording]); + + const startRecording = async () => { + try { + setPermissionError(null); + finalTranscriptRef.current = ""; + setInterimTranscript(""); + + if (!recognitionRef.current) { + throw new Error("Speech recognition not initialized"); + } + + recognitionRef.current.start(); + setIsRecording(true); + + // Start timer + timerRef.current = setInterval(() => { + setRecordingTime((prev) => prev + 1); + }, 1000); + + } catch (err: any) { + console.error("Error starting speech recognition:", err); + const errorMessage = "Could not start voice recognition. Please check permissions."; + setPermissionError(errorMessage); + onError(errorMessage); + } + }; + + const stopRecording = () => { + if (recognitionRef.current && isRecording) { + recognitionRef.current.stop(); + setIsRecording(false); + + // Reset timer + if (timerRef.current) { + clearInterval(timerRef.current); + } + setRecordingTime(0); + + // Send the final transcript + const fullTranscript = (finalTranscriptRef.current + ' ' + interimTranscript).trim(); + if (fullTranscript) { + onTranscriptionComplete(fullTranscript); + } else { + onError("No speech detected. Please try again."); + } + + setInterimTranscript(""); + } + }; + + const formatTime = (seconds: number): string => { + const mins = Math.floor(seconds / 60); + const secs = seconds % 60; + return `${mins}:${secs.toString().padStart(2, '0')}`; + }; + + return ( + + + Voice Input + + + {permissionError && ( + + {permissionError} + + )} + + + {!isRecording ? ( + + + + ) : ( + + + + )} + + + {isRecording && ( + + + Listening... + + + {formatTime(recordingTime)} + + {(finalTranscriptRef.current || interimTranscript) && ( + + + {finalTranscriptRef.current} + + {interimTranscript} + + + + )} + + )} + + {!isRecording && ( + + Click the microphone to start voice recognition +
+ + Speak in Russian or English + + + )} + + ); +}; + diff --git a/niffler-ng-client/src/pages/AISpendingPage/index.tsx b/niffler-ng-client/src/pages/AISpendingPage/index.tsx new file mode 100644 index 000000000..48b0d0eb9 --- /dev/null +++ b/niffler-ng-client/src/pages/AISpendingPage/index.tsx @@ -0,0 +1,11 @@ +import { Container } from "@mui/material"; +import { AISpendingForm } from "../../components/AISpendingForm"; + +export const AISpendingPage = () => { + return ( + + + + ) +} + diff --git a/niffler-userdata/src/main/resources/application.yaml b/niffler-userdata/src/main/resources/application.yaml index 8377e4a6c..84ea723cf 100644 --- a/niffler-userdata/src/main/resources/application.yaml +++ b/niffler-userdata/src/main/resources/application.yaml @@ -63,8 +63,8 @@ spring: niffler-userdata: base-uri: 'http://localhost:8089' firebase: - enabled: true - path: ${GOOGLE_APPLICATION_CREDENTIALS} + enabled: false + path: ${GOOGLE_APPLICATION_CREDENTIALS:} --- spring: config: diff --git a/settings.gradle b/settings.gradle index 4b3f8cbfc..bf869e439 100644 --- a/settings.gradle +++ b/settings.gradle @@ -4,5 +4,6 @@ include 'niffler-auth' include 'niffler-currency' include 'niffler-userdata' include 'niffler-spend' +include 'niffler-ai' include 'niffler-grpc-common' include 'niffler-e-2-e-tests' diff --git a/start-all-local.sh b/start-all-local.sh new file mode 100755 index 000000000..5c0c4bc9c --- /dev/null +++ b/start-all-local.sh @@ -0,0 +1,86 @@ +#!/bin/bash + +echo "🚀 Starting all Niffler services locally..." + +# Kill any existing services +echo "🛑 Stopping existing services..." +pkill -9 -f "niffler.*bootRun" 2>/dev/null +pkill -9 -f "niffler-ai.*jar" 2>/dev/null +sleep 2 + +# Start services in order +echo "📦 Starting base services..." + +# Start Auth service (port 9000) +nohup ./gradlew :niffler-auth:bootRun --args='--spring.profiles.active=local' > /tmp/niffler-auth.log 2>&1 & +echo " ✓ Auth starting on port 9000" + +# Start Currency service (port 8091, 8092) +nohup ./gradlew :niffler-currency:bootRun --args='--spring.profiles.active=local' > /tmp/niffler-currency.log 2>&1 & +echo " ✓ Currency starting on port 8091/8092" + +# Start Userdata service (port 8089) +nohup ./gradlew :niffler-userdata:bootRun --args='--spring.profiles.active=local' > /tmp/niffler-userdata.log 2>&1 & +echo " ✓ Userdata starting on port 8089" + +# Start Spend service (port 8093) +nohup ./gradlew :niffler-spend:bootRun --args='--spring.profiles.active=local' > /tmp/niffler-spend.log 2>&1 & +echo " ✓ Spend starting on port 8093" + +echo "⏳ Waiting for base services to start (40 seconds)..." +sleep 40 + +# Start Gateway service (port 8090) +echo "🌐 Starting Gateway..." +nohup ./gradlew :niffler-gateway:bootRun --args='--spring.profiles.active=local' > /tmp/niffler-gateway.log 2>&1 & +echo " ✓ Gateway starting on port 8090" + +# Start AI service (port 8094) +echo "🤖 Starting AI service..." +# Set Ollama API token (required) +export OLLAMA_API_TOKEN=${OLLAMA_API_TOKEN:-sk-xxx} +nohup java -jar -Dspring.profiles.active=local niffler-ai/build/libs/niffler-ai-2.0.5.jar > /tmp/niffler-ai.log 2>&1 & +echo " ✓ AI service starting on port 8094" + +echo "⏳ Waiting for Gateway and AI to start (15 seconds)..." +sleep 15 + +# Check running services +echo "" +echo "📊 Service Status:" +echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━" + +check_service() { + local port=$1 + local name=$2 + if lsof -i :$port -sTCP:LISTEN > /dev/null 2>&1; then + echo "✅ $name running on port $port" + else + echo "❌ $name NOT running on port $port" + fi +} + +check_service 9000 "Auth" +check_service 8089 "Userdata" +check_service 8091 "Currency" +check_service 8093 "Spend" +check_service 8090 "Gateway" +check_service 8094 "AI" + +echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━" +echo "" +echo "📝 Logs are available in /tmp/" +echo " - Auth: /tmp/niffler-auth.log" +echo " - Currency: /tmp/niffler-currency.log" +echo " - Userdata: /tmp/niffler-userdata.log" +echo " - Spend: /tmp/niffler-spend.log" +echo " - Gateway: /tmp/niffler-gateway.log" +echo " - AI: /tmp/niffler-ai.log" +echo "" +echo "🌐 Application URLs:" +echo " - Frontend: http://localhost:3000" +echo " - Gateway API: http://localhost:8090" +echo " - AI Service: http://localhost:8094/api/ai/health" +echo "" +echo "🛑 To stop all services: pkill -9 -f 'niffler.*bootRun'; pkill -9 -f 'niffler-ai.*jar'" + From 41089016baf50da9f18023b857e14a7a344cbb69 Mon Sep 17 00:00:00 2001 From: svasenkov Date: Fri, 24 Oct 2025 13:04:03 +0300 Subject: [PATCH 2/2] frontend now uses gateway for ai --- AI_SERVICE_SETUP.md | 51 ++++++++++++++++-- .../qa/niffler/controller/AiController.java | 53 +++++++++++++++++++ .../niffler/model/ParseSpendingRequest.java | 12 +++++ .../niffler/model/ParseSpendingResponse.java | 22 ++++++++ .../guru/qa/niffler/service/AiClient.java | 15 ++++++ .../qa/niffler/service/api/RestAiClient.java | 48 +++++++++++++++++ .../src/main/resources/application.yaml | 8 +++ niffler-ng-client/src/api/aiService.ts | 14 ++++- .../src/components/AISpendingForm/index.tsx | 2 +- settings.gradle | 25 ++++++--- start-all-local.sh | 13 +++-- 11 files changed, 243 insertions(+), 20 deletions(-) create mode 100644 niffler-gateway/src/main/java/guru/qa/niffler/controller/AiController.java create mode 100644 niffler-gateway/src/main/java/guru/qa/niffler/model/ParseSpendingRequest.java create mode 100644 niffler-gateway/src/main/java/guru/qa/niffler/model/ParseSpendingResponse.java create mode 100644 niffler-gateway/src/main/java/guru/qa/niffler/service/AiClient.java create mode 100644 niffler-gateway/src/main/java/guru/qa/niffler/service/api/RestAiClient.java diff --git a/AI_SERVICE_SETUP.md b/AI_SERVICE_SETUP.md index 88db15c6e..99d1596c1 100644 --- a/AI_SERVICE_SETUP.md +++ b/AI_SERVICE_SETUP.md @@ -9,7 +9,11 @@ ``` Frontend (niffler-ng-client) ↓ - → http://localhost:8094/api/ai/parse-spending + → http://localhost:8090/api/ai/parse-spending (Gateway) + ↓ +Gateway (niffler-gateway) + ↓ + → http://localhost:8094/api/ai/parse-spending (AI Service) ↓ AI Service (niffler-ai) ↓ @@ -18,6 +22,8 @@ AI Service (niffler-ai) Ollama API (openchat:latest) ``` +**Важно:** Все запросы к AI сервису идут через Gateway (порт 8090). + ## 🚀 Что было сделано ### 1. Создан микросервис `niffler-ai` @@ -78,10 +84,10 @@ AI service is running ### 3. Обновлен фронтенд -Файл `niffler-ng-client/src/api/aiService.ts` теперь обращается к микросервису вместо прямого запроса к Ollama: +Файл `niffler-ng-client/src/api/aiService.ts` теперь обращается к Gateway вместо прямого запроса к AI сервису: ```typescript -const AI_SERVICE_URL = 'http://localhost:8093/api/ai'; +const AI_SERVICE_URL = 'http://localhost:8090/api/ai'; export const aiService = { parseSpending: async (userInput: string): Promise => { @@ -99,7 +105,33 @@ export const aiService = { }; ``` -### 4. Добавлен в Docker Compose +### 4. Добавлена интеграция в Gateway + +**Структура в Gateway:** +``` +niffler-gateway/ +├── src/main/java/guru/qa/niffler/ +│ ├── controller/ +│ │ └── AiController.java # Контроллер для AI endpoints +│ ├── service/ +│ │ ├── AiClient.java # Интерфейс AI клиента +│ │ └── api/ +│ │ └── RestAiClient.java # REST клиент для AI сервиса +│ └── model/ +│ ├── ParseSpendingRequest.java +│ └── ParseSpendingResponse.java +└── src/main/resources/ + └── application.yaml # Добавлена конфигурация niffler-ai +``` + +**Конфигурация в application.yaml:** +```yaml +niffler-ai: + base-uri: 'http://localhost:8094' # local + base-uri: 'http://ai.niffler.dc:8094' # docker +``` + +### 5. Добавлен в Docker Compose ```yaml ai.niffler.dc: @@ -133,7 +165,7 @@ java -jar niffler-ai/build/libs/niffler-ai-2.0.5.jar ./gradlew :niffler-ai:bootRun ``` -3. Проверить работу: +3. Проверить работу напрямую (для тестирования): ```bash curl -X GET http://localhost:8094/api/ai/health # Ответ: AI service is running @@ -143,6 +175,15 @@ curl -X POST http://localhost:8094/api/ai/parse-spending \ -d '{"userInput":"Купил кофе за 300 рублей"}' ``` +4. **Рекомендуется:** Проверить работу через Gateway: +```bash +# Нужна авторизация через OAuth2 токен +curl -X POST http://localhost:8090/api/ai/parse-spending \ + -H "Content-Type: application/json" \ + -H "Authorization: Bearer YOUR_JWT_TOKEN" \ + -d '{"userInput":"Купил кофе за 300 рублей"}' +``` + ### Docker запуск 1. Собрать Docker образ: diff --git a/niffler-gateway/src/main/java/guru/qa/niffler/controller/AiController.java b/niffler-gateway/src/main/java/guru/qa/niffler/controller/AiController.java new file mode 100644 index 000000000..7d9561fc5 --- /dev/null +++ b/niffler-gateway/src/main/java/guru/qa/niffler/controller/AiController.java @@ -0,0 +1,53 @@ +package guru.qa.niffler.controller; + +import guru.qa.niffler.config.NifflerGatewayServiceConfig; +import guru.qa.niffler.model.ParseSpendingRequest; +import guru.qa.niffler.model.ParseSpendingResponse; +import guru.qa.niffler.service.AiClient; +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.security.SecurityRequirement; +import io.swagger.v3.oas.annotations.tags.Tag; +import jakarta.validation.Valid; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +@RestController +@RequestMapping("/api/ai") +@SecurityRequirement(name = NifflerGatewayServiceConfig.OPEN_API_AUTH_SCHEME) +@Tag(name = "AI Controller", description = "AI service integration for parsing spending information") +public class AiController { + + private static final Logger LOG = LoggerFactory.getLogger(AiController.class); + + private final AiClient aiClient; + + @Autowired + public AiController(AiClient aiClient) { + this.aiClient = aiClient; + } + + @PostMapping("/parse-spending") + @Operation( + summary = "Parse spending information", + description = "Parses natural language spending description using AI" + ) + public ParseSpendingResponse parseSpending( + @Parameter(description = "User input containing spending information") + @Valid @RequestBody ParseSpendingRequest request) { + + LOG.info("Received request to parse spending through gateway: {}", request.userInput()); + + ParseSpendingResponse response = aiClient.parseSpending(request); + + LOG.info("Successfully parsed spending: {}", response); + + return response; + } +} + diff --git a/niffler-gateway/src/main/java/guru/qa/niffler/model/ParseSpendingRequest.java b/niffler-gateway/src/main/java/guru/qa/niffler/model/ParseSpendingRequest.java new file mode 100644 index 000000000..44d631410 --- /dev/null +++ b/niffler-gateway/src/main/java/guru/qa/niffler/model/ParseSpendingRequest.java @@ -0,0 +1,12 @@ +package guru.qa.niffler.model; + +import com.fasterxml.jackson.annotation.JsonProperty; +import jakarta.validation.constraints.NotBlank; + +public record ParseSpendingRequest( + @JsonProperty("userInput") + @NotBlank(message = "User input must not be blank") + String userInput +) { +} + diff --git a/niffler-gateway/src/main/java/guru/qa/niffler/model/ParseSpendingResponse.java b/niffler-gateway/src/main/java/guru/qa/niffler/model/ParseSpendingResponse.java new file mode 100644 index 000000000..590c93b11 --- /dev/null +++ b/niffler-gateway/src/main/java/guru/qa/niffler/model/ParseSpendingResponse.java @@ -0,0 +1,22 @@ +package guru.qa.niffler.model; + +import com.fasterxml.jackson.annotation.JsonProperty; + +public record ParseSpendingResponse( + @JsonProperty("amount") + double amount, + + @JsonProperty("category") + String category, + + @JsonProperty("description") + String description, + + @JsonProperty("currency") + String currency, + + @JsonProperty("spendDate") + String spendDate +) { +} + diff --git a/niffler-gateway/src/main/java/guru/qa/niffler/service/AiClient.java b/niffler-gateway/src/main/java/guru/qa/niffler/service/AiClient.java new file mode 100644 index 000000000..874958abe --- /dev/null +++ b/niffler-gateway/src/main/java/guru/qa/niffler/service/AiClient.java @@ -0,0 +1,15 @@ +package guru.qa.niffler.service; + +import guru.qa.niffler.model.ParseSpendingRequest; +import guru.qa.niffler.model.ParseSpendingResponse; +import jakarta.annotation.Nonnull; + +import javax.annotation.ParametersAreNonnullByDefault; + +@ParametersAreNonnullByDefault +public interface AiClient { + + @Nonnull + ParseSpendingResponse parseSpending(ParseSpendingRequest request); +} + diff --git a/niffler-gateway/src/main/java/guru/qa/niffler/service/api/RestAiClient.java b/niffler-gateway/src/main/java/guru/qa/niffler/service/api/RestAiClient.java new file mode 100644 index 000000000..feb4bf344 --- /dev/null +++ b/niffler-gateway/src/main/java/guru/qa/niffler/service/api/RestAiClient.java @@ -0,0 +1,48 @@ +package guru.qa.niffler.service.api; + +import guru.qa.niffler.ex.NoRestResponseException; +import guru.qa.niffler.model.ParseSpendingRequest; +import guru.qa.niffler.model.ParseSpendingResponse; +import guru.qa.niffler.service.AiClient; +import jakarta.annotation.Nonnull; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.stereotype.Component; +import org.springframework.web.client.RestTemplate; + +import javax.annotation.ParametersAreNonnullByDefault; +import java.util.Optional; + +@Component +@ParametersAreNonnullByDefault +public class RestAiClient implements AiClient { + + private static final Logger LOG = LoggerFactory.getLogger(RestAiClient.class); + + private final RestTemplate restTemplate; + private final String nifflerAiApiUri; + + @Autowired + public RestAiClient(RestTemplate restTemplate, + @Value("${niffler-ai.base-uri}") String nifflerAiBaseUri) { + this.restTemplate = restTemplate; + this.nifflerAiApiUri = nifflerAiBaseUri + "/api/ai"; + } + + @Nonnull + @Override + public ParseSpendingResponse parseSpending(ParseSpendingRequest request) { + LOG.info("Forwarding request to AI service: {}", request); + + return Optional.ofNullable( + restTemplate.postForObject( + nifflerAiApiUri + "/parse-spending", + request, + ParseSpendingResponse.class + ) + ).orElseThrow(() -> new NoRestResponseException("No REST ParseSpendingResponse response is given [/api/ai/parse-spending Route]")); + } +} + diff --git a/niffler-gateway/src/main/resources/application.yaml b/niffler-gateway/src/main/resources/application.yaml index e43d269eb..f077ab024 100644 --- a/niffler-gateway/src/main/resources/application.yaml +++ b/niffler-gateway/src/main/resources/application.yaml @@ -50,6 +50,8 @@ niffler-userdata: base-uri: 'http://localhost:8089' niffler-spend: base-uri: 'http://localhost:8093' +niffler-ai: + base-uri: 'http://localhost:8094' niffler-front: base-uri: 'http://localhost:3000' niffler-gateway: @@ -82,6 +84,8 @@ niffler-userdata: base-uri: 'http://userdata.niffler.dc:8089' niffler-spend: base-uri: 'http://spend.niffler.dc:8093' +niffler-ai: + base-uri: 'http://ai.niffler.dc:8094' niffler-front: base-uri: 'http://frontend.niffler.dc' niffler-gateway: @@ -124,6 +128,8 @@ niffler-userdata: base-uri: ${niffler-userdata.url} niffler-spend: base-uri: ${niffler-spend.url} +niffler-ai: + base-uri: ${niffler-ai.url} niffler-front: base-uri: 'https://niffler.qa.guru' niffler-gateway: @@ -166,6 +172,8 @@ niffler-userdata: base-uri: ${niffler-userdata.url} niffler-spend: base-uri: ${niffler-spend.url} +niffler-ai: + base-uri: ${niffler-ai.url} niffler-front: base-uri: 'https://niffler-stage.qa.guru' niffler-gateway: diff --git a/niffler-ng-client/src/api/aiService.ts b/niffler-ng-client/src/api/aiService.ts index bc8612a7e..3a1e868dc 100644 --- a/niffler-ng-client/src/api/aiService.ts +++ b/niffler-ng-client/src/api/aiService.ts @@ -1,4 +1,6 @@ -const AI_SERVICE_URL = 'http://localhost:8094/api/ai'; +import { bearerToken } from './authUtils.ts'; + +const AI_SERVICE_URL = 'http://localhost:8090/api/ai'; export interface SpendingFromAI { amount: number; @@ -10,10 +12,12 @@ export interface SpendingFromAI { export const aiService = { parseSpending: async (userInput: string): Promise => { + const token = await bearerToken(); const response = await fetch(`${AI_SERVICE_URL}/parse-spending`, { method: 'POST', headers: { 'Content-Type': 'application/json', + 'Authorization': token, }, body: JSON.stringify({ userInput: userInput, @@ -42,11 +46,15 @@ export const aiService = { }, transcribeAudio: async (audioBlob: Blob): Promise => { + const token = await bearerToken(); const formData = new FormData(); formData.append('audio', audioBlob, 'recording.webm'); const response = await fetch(`${AI_SERVICE_URL}/transcribe-audio`, { method: 'POST', + headers: { + 'Authorization': token, + }, body: formData, }); @@ -65,11 +73,15 @@ export const aiService = { }, parseSpendingFromAudio: async (audioBlob: Blob): Promise => { + const token = await bearerToken(); const formData = new FormData(); formData.append('audio', audioBlob, 'recording.webm'); const response = await fetch(`${AI_SERVICE_URL}/parse-spending-from-audio`, { method: 'POST', + headers: { + 'Authorization': token, + }, body: formData, }); diff --git a/niffler-ng-client/src/components/AISpendingForm/index.tsx b/niffler-ng-client/src/components/AISpendingForm/index.tsx index 6e943aec9..256f2b641 100644 --- a/niffler-ng-client/src/components/AISpendingForm/index.tsx +++ b/niffler-ng-client/src/components/AISpendingForm/index.tsx @@ -1,4 +1,4 @@ -import { Button, Grid, TextField, Typography, useTheme, Alert, Box, Tabs, Tab, Divider } from "@mui/material"; +import { Button, Grid, TextField, Typography, useTheme, Alert, Box, Tabs, Tab } from "@mui/material"; import { FC, FormEvent, useState } from "react"; import { aiService, SpendingFromAI } from "../../api/aiService.ts"; import { apiClient } from "../../api/apiClient.ts"; diff --git a/settings.gradle b/settings.gradle index bf869e439..734078096 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1,9 +1,18 @@ rootProject.name = 'niffler' -include 'niffler-gateway' -include 'niffler-auth' -include 'niffler-currency' -include 'niffler-userdata' -include 'niffler-spend' -include 'niffler-ai' -include 'niffler-grpc-common' -include 'niffler-e-2-e-tests' + +def modules = [ + 'niffler-gateway', + 'niffler-auth', + 'niffler-currency', + 'niffler-userdata', + 'niffler-spend', + 'niffler-ai', + 'niffler-grpc-common', + 'niffler-e-2-e-tests' +] + +modules.each { m -> + if (file(m).exists()) { + include m + } +} \ No newline at end of file diff --git a/start-all-local.sh b/start-all-local.sh index 5c0c4bc9c..9b34d2d9d 100755 --- a/start-all-local.sh +++ b/start-all-local.sh @@ -15,9 +15,9 @@ echo "📦 Starting base services..." nohup ./gradlew :niffler-auth:bootRun --args='--spring.profiles.active=local' > /tmp/niffler-auth.log 2>&1 & echo " ✓ Auth starting on port 9000" -# Start Currency service (port 8091, 8092) +# Start Currency service (gRPC port 8092) nohup ./gradlew :niffler-currency:bootRun --args='--spring.profiles.active=local' > /tmp/niffler-currency.log 2>&1 & -echo " ✓ Currency starting on port 8091/8092" +echo " ✓ Currency starting on port 8092 (gRPC)" # Start Userdata service (port 8089) nohup ./gradlew :niffler-userdata:bootRun --args='--spring.profiles.active=local' > /tmp/niffler-userdata.log 2>&1 & @@ -37,8 +37,10 @@ echo " ✓ Gateway starting on port 8090" # Start AI service (port 8094) echo "🤖 Starting AI service..." -# Set Ollama API token (required) -export OLLAMA_API_TOKEN=${OLLAMA_API_TOKEN:-sk-xxx} +# Load environment variables from .env file +if [ -f .env ]; then + export $(cat .env | grep -v '^#' | grep OLLAMA | xargs) +fi nohup java -jar -Dspring.profiles.active=local niffler-ai/build/libs/niffler-ai-2.0.5.jar > /tmp/niffler-ai.log 2>&1 & echo " ✓ AI service starting on port 8094" @@ -62,7 +64,7 @@ check_service() { check_service 9000 "Auth" check_service 8089 "Userdata" -check_service 8091 "Currency" +check_service 8092 "Currency (gRPC)" check_service 8093 "Spend" check_service 8090 "Gateway" check_service 8094 "AI" @@ -84,3 +86,4 @@ echo " - AI Service: http://localhost:8094/api/ai/health" echo "" echo "🛑 To stop all services: pkill -9 -f 'niffler.*bootRun'; pkill -9 -f 'niffler-ai.*jar'" +