[AI] - Integrate OpenAI (or similar AI service) for real-time conversation practice functionality

[Gerson2102]

📘 Issue Description

Integrate OpenAI (or similar AI service) for real-time conversation practice functionality. This feature will allow authenticated users to engage in AI-powered conversations to practice their language skills. The implementation should include a secure /chat/ai POST endpoint that handles chat requests and responses while maintaining user authentication and proper error handling.

🔍 Steps

Backend Implementation

1. Install OpenAI SDK

   • Add openai package to dependencies
   • Add OpenAI API key configuration to environment variables and settings

2. Create Chat Controller

   • Create src/controllers/chat.controller.ts
   • Implement sendMessage method for handling chat requests
   • Handle OpenAI API integration with proper error handling
   • Support conversation context/history management

3. Create Chat Service

   • Create src/services/chat.service.ts
   • Implement OpenAI API calls with proper configuration
   • Handle rate limiting and token management
   • Support different conversation modes (practice levels: A1, A2, B1, B2, C1, C2)

4. Create Chat Routes

   • Create src/routes/api/modules/chat.routes.ts
   • Implement POST /api/v1/chat/ai endpoint
   • Apply authentication middleware (isAuthorized())
   • Add request validation middleware

5. Create Validation Schema

   • Create src/models/validations/chat.validators.ts
   • Validate message content, conversation context, and practice level
   • Ensure proper sanitization of user input

6. Environment Configuration

   • Add OPENAI_API_KEY to environment variables
   • Add OPENAI_MODEL configuration (default: gpt-3.5-turbo)
   • Update settings schema in src/core/config/settings.ts

7. Error Handling & Security

   • Implement proper error responses for API failures
   • Add rate limiting specific to chat endpoints
   • Sanitize user input and AI responses
   • Handle OpenAI API quota limits gracefully

Database Considerations (Optional Enhancement)

8. Chat History Storage
   • Consider adding chat history tables to Prisma schema
   • Store conversation sessions for user progress tracking
   • Implement data retention policies

✅ Acceptance Criteria

• Authentication Required: Only authenticated users can access the chat endpoint
• Secure API Integration: OpenAI API key is properly configured and secured
• Request Validation: All incoming chat requests are validated (message content, length limits)
• Error Handling: Proper error responses for API failures, rate limits, and invalid requests
• Rate Limiting: Chat endpoint has appropriate rate limiting to prevent abuse
• Response Format: Consistent API response format following existing patterns (SuccessResponse, BadRequestResponse)
• Environment Configuration: OpenAI configuration is managed through environment variables
• TypeScript Support: Full TypeScript implementation with proper type definitions
• Logging: Proper logging for chat interactions and API calls
• Testing: Unit tests for chat service and controller methods

API Specification

Endpoint: POST /api/v1/chat/ai

Headers:

• Authorization: Bearer <jwt_token>

• Content-Type: application/json

Request Body:

{
  "message": "Hello, I want to practice English conversation",
  "conversationContext": [],
  "practiceLevel": "B1",
  "conversationType": "general"
}

Success Response (200):

{
  "success": true,
  "message": "Chat response generated successfully",
  "data": {
    "response": "Hello! I'd be happy to help you practice English...",
    "conversationId": "uuid-string",
    "timestamp": "2024-01-15T10:30:00Z"
  }
}

🌎 References

• OpenAI API Documentation
• OpenAI Node.js SDK
• Existing codebase patterns in /src/controllers/ and /src/services/
• Authentication patterns in /src/middlewares/authentication.ts
• Validation patterns in /src/models/validations/

📜 Additional Notes

Technical Considerations

1. Cost Management: Implement token counting and usage tracking to manage OpenAI API costs
2. Performance: Consider implementing response caching for common practice scenarios
3. Scalability: Design with future multi-language support in mind
4. Privacy: Ensure user messages are handled according to privacy policies
5. Fallback: Consider fallback responses if OpenAI API is unavailable

Integration Points

• Follow existing controller patterns (auth.controller.ts, question.controller.ts)
• Use existing authentication middleware (isAuthorized())
• Follow validation patterns from question.validators.ts
• Maintain consistency with existing API response formats
• Use existing logging configuration from core/config/logger.ts

[LaGodxy]

I'd like to take on this feature and implement the AI-powered conversation endpoint.

🔧 Planned Work:

• Integrate OpenAI using the openai SDK with secure environment-based configuration.

• Implement the chat.controller.ts and chat.service.ts to handle /api/v1/chat/ai requests, including:

  • User authentication via middleware.
  • Request validation (message, context, level).
  • Secure API call to OpenAI with error handling, rate limiting, and fallback support.

• Support conversation context and multiple CEFR practice levels (A1–C2).

• Ensure full TypeScript typing, input/output sanitization, and standardized API responses.

• (Optional) Structure for persisting chat history to support user progress tracking.

🧪 Testing & Quality:

• Unit and integration tests for controller and service logic.
• Proper logging and error tracing.
• Rate limiting and quota handling for OpenAI usage.

A draft PR will be submitted within 48–72 hours. Please assign me to this issue.

[Josue19-08]

🛡 Custom Development Environment with Supabase

@LaGodxy
Dear contributor,

As part of our recent updates, the project database has been migrated to Supabase. For security reasons, we do not store real credentials in development. Each developer must create their own Supabase project and configure their local environment accordingly.

Setup Steps

1. Clone or fork this repository.

2. Create a free project on Supabase:
   https://app.supabase.com

3. Locate the Prisma schema in:

   prisma/schema.prisma

4. Apply Prisma migrations to create the required tables in your Supabase database:

   npx prisma db push

5. Add your Supabase credentials to a .env.local file at the project root, following the structure in .env.example:

   DATABASE_URL="postgresql://postgres:your_password@db.your-project.supabase.co:5432/your_database?pgbouncer=true"
   DIRECT_URL="postgresql://postgres:your_password@db.your-project.supabase.co:5432/your_database"

6. Install dependencies and start the development server:

   npm install
   npm run dev

---

💡 Important: Always update your .env.local using the provided .env.example as reference and avoid committing your real credentials to version control.

---

✅ Let us know if you need any help setting up Supabase for your local environment.

[salazarsebas]

Hello Aurora Team,

My background

My name is Sebastián, and I'm part of the Dojo Coding community ⛩️💻 I'm excited about the opportunity to contribute to your Stellar-based project during ODWave! 🚀

Experience

I'm a full-stack developer with experience in Web3 and blockchain technologies, particularly in projects involving smart contracts and decentralized solutions. I have worked on projects mainly based on Stellar.

I am motivated by the opportunity to improve my skills and contribute to the project.

Links

You can find my profiles and links here:

GitHub: https://github.com/salazarsebas

OnlyDust: https://app.onlydust.com/users/salazarsebas/overview

Thank you for considering my candidacy. I am excited about the opportunity to contribute to this project and create a positive impact. Please let me know if you have any questions or need additional information.

Best regards, Sebastián!

Recommended by OnlyDust for high-quality and dependable contributions.

[dimka90]

I am an experienced backend developer with many years of experience in developing both backend and decentralized applications. I have also created AI products that utilize OpenAI. This task looks exciting, and I will love to take it

links to two products that I utilize, openAI, to create.

https://github.com/dimka90/SIla.git
https://github.com/dimka90/indexer.git