Update app.py

app.py

@@ -1,408 +1,372 @@
-import React, { useState, useRef, useEffect } from 'react';
-import { Mic, MicOff, Volume2, Globe, Loader2 } from 'lucide-react';
-
-const RealtimeVoiceTranslator = () => {
-  const [isConnected, setIsConnected] = useState(false);
-  const [isRecording, setIsRecording] = useState(false);
-  const [transcript, setTranscript] = useState('');
-  const [translation, setTranslation] = useState('');
-  const [sourceLanguage, setSourceLanguage] = useState('ko');
-  const [targetLanguage, setTargetLanguage] = useState('en');
-  const [ephemeralKey, setEphemeralKey] = useState('');
-  const [logs, setLogs] = useState([]);
-  const [isLoading, setIsLoading] = useState(false);
-
-  const pcRef = useRef(null);
-  const dcRef = useRef(null);
-  const audioElRef = useRef(null);
-
-  // 로그 추가 함수
-  const addLog = (message, type = 'info') => {
-    const timestamp = new Date().toLocaleTimeString();
-    setLogs(prev => [...prev, { message, type, timestamp }]);
-  };
-
-  // Ephemeral key 가져오기 (시뮬레이션)
-  const getEphemeralKey = async () => {
-    // 실제 구현에서는 서버에서 ephemeral key를 가져와야 합니다
-    addLog('Ephemeral key가 필요합니다. 서버 엔드포인트를 구현해주세요.', 'warning');
-    return 'YOUR_EPHEMERAL_KEY';
-  };
-
-  // WebRTC 연결 초기화
-  const initializeConnection = async () => {
-    try {
-      setIsLoading(true);
-      addLog('연결 초기화 중...', 'info');
-
-      // Ephemeral key 가져오기
-      const key = await getEphemeralKey();
-      setEphemeralKey(key);
-
-      // Peer connection 생성
-      const pc = new RTCPeerConnection({
-        iceServers: [{ urls: 'stun:stun.l.google.com:19302' }]
-      });
-      pcRef.current = pc;
-
-      // 원격 오디오 스트림 설정
-      const audioEl = audioElRef.current;
-      pc.ontrack = (e) => {
-        audioEl.srcObject = e.streams[0];
-        addLog('오디오 스트림 연결됨', 'success');
-      };
-
-      // 로컬 오디오 트랙 추가
-      const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
-      stream.getTracks().forEach(track => {
-        pc.addTrack(track, stream);
-      });
-
-      // 데이터 채널 설정
-      const dc = pc.createDataChannel('oai-events');
-      dcRef.current = dc;
-
-      dc.addEventListener('open', () => {
-        addLog('데이터 채널 열림', 'success');
-        setIsConnected(true);
+import gradio as gr
+import websocket
+import json
+import base64
+import numpy as np
+import threading
+import queue
+import os
+from datetime import datetime
+import pyaudio
+import wave
+import io
+
+class RealtimeTranslator:
+    def __init__(self):
+        self.ws = None
+        self.api_key = os.getenv("OPENAI_API_KEY")
+        self.audio_queue = queue.Queue()
+        self.transcript_queue = queue.Queue()
+        self.translation_queue = queue.Queue()
+        self.is_connected = False
+        self.is_recording = False
+        self.source_lang = "ko"
+        self.target_lang = "en"
         
-        // 세션 설정
-        const sessionConfig = {
-          type: 'session.update',
-          session: {
-            modalities: ['text', 'audio'],
-            instructions: `You are a helpful translator. Translate between ${sourceLanguage === 'ko' ? 'Korean' : 'English'} and ${targetLanguage === 'ko' ? 'Korean' : 'English'}.`,
-            voice: 'alloy',
-            input_audio_format: 'pcm16',
-            output_audio_format: 'pcm16',
-            input_audio_transcription: {
-              model: 'whisper-1'
-            },
-            turn_detection: {
-              type: 'server_vad',
-              threshold: 0.5,
-              prefix_padding_ms: 300,
-              silence_duration_ms: 500
+        # PyAudio 설정
+        self.p = pyaudio.PyAudio()
+        self.sample_rate = 24000
+        self.chunk_size = 1024
+        self.audio_format = pyaudio.paInt16
+        
+    def connect_websocket(self):
+        """WebSocket 연결 설정"""
+        try:
+            url = "wss://api.openai.com/v1/realtime?model=gpt-4o-realtime-preview-2024-12-17"
+            headers = {
+                "Authorization": f"Bearer {self.api_key}",
+                "OpenAI-Beta": "realtime=v1"
+            }
+            
+            self.ws = websocket.WebSocketApp(
+                url,
+                header=headers,
+                on_open=self.on_open,
+                on_message=self.on_message,
+                on_error=self.on_error,
+                on_close=self.on_close
+            )
+            
+            # WebSocket을 별도 스레드에서 실행
+            wst = threading.Thread(target=self.ws.run_forever)
+            wst.daemon = True
+            wst.start()
+            
+            return "연결 성공"
+        except Exception as e:
+            return f"연결 실패: {str(e)}"
+    
+    def on_open(self, ws):
+        """WebSocket 연결 시 호출"""
+        self.is_connected = True
+        print("WebSocket 연결됨")
+        
+        # 세�� 설정
+        session_update = {
+            "type": "session.update",
+            "session": {
+                "modalities": ["text", "audio"],
+                "instructions": f"You are a helpful translator. Translate between {self.get_language_name(self.source_lang)} and {self.get_language_name(self.target_lang)}. Respond with both the transcription and translation.",
+                "voice": "alloy",
+                "input_audio_format": "pcm16",
+                "output_audio_format": "pcm16",
+                "input_audio_transcription": {
+                    "model": "whisper-1"
+                },
+                "turn_detection": {
+                    "type": "server_vad",
+                    "threshold": 0.5,
+                    "prefix_padding_ms": 300,
+                    "silence_duration_ms": 500
+                }
             }
-          }
-        };
-        dc.send(JSON.stringify(sessionConfig));
-      });
-
-      dc.addEventListener('message', (e) => {
-        const event = JSON.parse(e.data);
-        handleRealtimeEvent(event);
-      });
-
-      dc.addEventListener('error', (error) => {
-        addLog(`데이터 채널 오류: ${error}`, 'error');
-      });
-
-      // SDP 오퍼 생성 및 연결
-      const offer = await pc.createOffer();
-      await pc.setLocalDescription(offer);
-
-      // API 연결 (실제 구현 시 사용)
-      /*
-      const baseUrl = 'https://api.openai.com/v1/realtime';
-      const model = 'gpt-4o-realtime-preview-2025-06-03';
-      const response = await fetch(`${baseUrl}?model=${model}`, {
-        method: 'POST',
-        body: offer.sdp,
-        headers: {
-          'Authorization': `Bearer ${key}`,
-          'Content-Type': 'application/sdp'
         }
-      });
-
-      const answerSdp = await response.text();
-      const answer = {
-        type: 'answer',
-        sdp: answerSdp
-      };
-      await pc.setRemoteDescription(answer);
-      */
-
-      addLog('WebRTC 연결 시뮬레이션 완료', 'warning');
-      setIsConnected(true);
-      setIsLoading(false);
-
-    } catch (error) {
-      addLog(`연결 오류: ${error.message}`, 'error');
-      setIsLoading(false);
-    }
-  };
-
-  // Realtime 이벤트 처리
-  const handleRealtimeEvent = (event) => {
-    switch (event.type) {
-      case 'conversation.item.created':
-        if (event.item.role === 'user') {
-          setTranscript(event.item.content?.[0]?.transcript || '');
-          addLog(`사용자: ${event.item.content?.[0]?.transcript}`, 'info');
+        ws.send(json.dumps(session_update))
+    
+    def on_message(self, ws, message):
+        """메시지 수신 시 호출"""
+        try:
+            event = json.loads(message)
+            event_type = event.get("type")
+            
+            if event_type == "conversation.item.input_audio_transcription.completed":
+                # 음성 전사 완료
+                transcript = event.get("transcript", "")
+                self.transcript_queue.put(transcript)
+                
+                # 번역 요청
+                self.request_translation(transcript)
+                
+            elif event_type == "response.text.delta":
+                # 번역 결과 수신
+                delta = event.get("delta", "")
+                self.translation_queue.put(delta)
+                
+            elif event_type == "response.audio.delta":
+                # 오디오 데이터 수신
+                audio_data = base64.b64decode(event.get("delta", ""))
+                self.audio_queue.put(audio_data)
+                
+            elif event_type == "error":
+                error_msg = event.get("error", {}).get("message", "Unknown error")
+                print(f"Error: {error_msg}")
+                
+        except Exception as e:
+            print(f"메시지 처리 오류: {str(e)}")
+    
+    def on_error(self, ws, error):
+        """오류 발생 시 호출"""
+        print(f"WebSocket 오류: {error}")
+        self.is_connected = False
+    
+    def on_close(self, ws, close_status_code, close_msg):
+        """연결 종료 시 호출"""
+        print("WebSocket 연결 종료")
+        self.is_connected = False
+    
+    def get_language_name(self, lang_code):
+        """언어 코드를 언어 이름으로 변환"""
+        languages = {
+            "ko": "Korean",
+            "en": "English",
+            "ja": "Japanese",
+            "zh": "Chinese",
+            "es": "Spanish",
+            "fr": "French"
         }
-        break;
-      
-      case 'conversation.item.input_audio_transcription.completed':
-        setTranscript(event.transcript);
-        addLog(`전사 완료: ${event.transcript}`, 'info');
-        // 번역 요청
-        requestTranslation(event.transcript);
-        break;
-      
-      case 'response.audio_transcript.delta':
-        setTranslation(prev => prev + event.delta);
-        break;
-      
-      case 'response.audio_transcript.done':
-        addLog(`번역 완료: ${translation}`, 'success');
-        break;
-      
-      case 'error':
-        addLog(`오류: ${event.error.message}`, 'error');
-        break;
-      
-      default:
-        console.log('Unhandled event:', event);
-    }
-  };
-
-  // 번역 요청
-  const requestTranslation = (text) => {
-    if (!dcRef.current || dcRef.current.readyState !== 'open') return;
-
-    const message = {
-      type: 'conversation.item.create',
-      item: {
-        type: 'message',
-        role: 'user',
-        content: [{
-          type: 'input_text',
-          text: `Translate this to ${targetLanguage === 'ko' ? 'Korean' : 'English'}: "${text}"`
-        }]
-      }
-    };
-
-    dcRef.current.send(JSON.stringify(message));
+        return languages.get(lang_code, lang_code)
     
-    // 응답 생성 요청
-    dcRef.current.send(JSON.stringify({ type: 'response.create' }));
-  };
-
-  // 녹음 시작/중지
-  const toggleRecording = () => {
-    if (!isConnected) {
-      addLog('먼저 연결을 시작해주세요', 'warning');
-      return;
-    }
-
-    setIsRecording(!isRecording);
+    def request_translation(self, text):
+        """번역 요청"""
+        if not self.ws or not self.is_connected:
+            return
+        
+        message = {
+            "type": "conversation.item.create",
+            "item": {
+                "type": "message",
+                "role": "user",
+                "content": [{
+                    "type": "input_text",
+                    "text": f"Translate this {self.get_language_name(self.source_lang)} text to {self.get_language_name(self.target_lang)}: '{text}'"
+                }]
+            }
+        }
+        
+        self.ws.send(json.dumps(message))
+        
+        # 응답 생성 요청
+        response_create = {"type": "response.create"}
+        self.ws.send(json.dumps(response_create))
     
-    if (!isRecording) {
-      addLog('녹음 시작', 'info');
-      // 음성 입력 시작을 위한 이벤트 전송
-      if (dcRef.current && dcRef.current.readyState === 'open') {
-        dcRef.current.send(JSON.stringify({
-          type: 'input_audio_buffer.commit'
-        }));
-      }
-    } else {
-      addLog('녹음 중지', 'info');
-    }
-  };
-
-  // 언어 전환
-  const swapLanguages = () => {
-    setSourceLanguage(targetLanguage);
-    setTargetLanguage(sourceLanguage);
-    addLog(`언어 전환: ${targetLanguage} → ${sourceLanguage}`, 'info');
-  };
-
-  // 연결 종료
-  const disconnect = () => {
-    if (pcRef.current) {
-      pcRef.current.close();
-      pcRef.current = null;
-    }
-    setIsConnected(false);
-    setIsRecording(false);
-    addLog('연결 종료됨', 'info');
-  };
-
-  // 컴포넌트 언마운트 시 정리
-  useEffect(() => {
-    return () => {
-      if (pcRef.current) {
-        pcRef.current.close();
-      }
-    };
-  }, []);
-
-  return (
-    <div className="min-h-screen bg-gray-50 p-4">
-      <div className="max-w-4xl mx-auto">
-        <h1 className="text-3xl font-bold text-center mb-8 text-gray-800">
-          실시간 음성 번역기
-        </h1>
-
-        {/* 연결 상태 */}
-        <div className="bg-white rounded-lg shadow-md p-6 mb-6">
-          <div className="flex items-center justify-between mb-4">
-            <h2 className="text-xl font-semibold">연결 상태</h2>
-            <div className="flex items-center gap-2">
-              <div className={`w-3 h-3 rounded-full ${isConnected ? 'bg-green-500' : 'bg-red-500'}`} />
-              <span className="text-sm">{isConnected ? '연결됨' : '연결 안됨'}</span>
-            </div>
-          </div>
-          
-          <div className="flex gap-4">
-            {!isConnected ? (
-              <button
-                onClick={initializeConnection}
-                disabled={isLoading}
-                className="flex items-center gap-2 px-4 py-2 bg-blue-500 text-white rounded-lg hover:bg-blue-600 disabled:bg-gray-400"
-              >
-                {isLoading ? (
-                  <>
-                    <Loader2 className="w-4 h-4 animate-spin" />
-                    연결 중...
-                  </>
-                ) : (
-                  '연결 시작'
-                )}
-              </button>
-            ) : (
-              <button
-                onClick={disconnect}
-                className="px-4 py-2 bg-red-500 text-white rounded-lg hover:bg-red-600"
-              >
-                연결 종료
-              </button>
-            )}
-          </div>
-        </div>
-
-        {/* 언어 선택 */}
-        <div className="bg-white rounded-lg shadow-md p-6 mb-6">
-          <div className="flex items-center justify-between gap-4">
-            <div className="flex-1">
-              <label className="block text-sm font-medium mb-2">입력 언어</label>
-              <select
-                value={sourceLanguage}
-                onChange={(e) => setSourceLanguage(e.target.value)}
-                className="w-full p-2 border rounded-lg"
-              >
-                <option value="ko">한국어</option>
-                <option value="en">영어</option>
-              </select>
-            </div>
+    def send_audio_chunk(self, audio_data):
+        """오디오 청크 전송"""
+        if not self.ws or not self.is_connected:
+            return
+        
+        # PCM16 형식으로 인코딩
+        audio_base64 = base64.b64encode(audio_data).decode('utf-8')
+        
+        message = {
+            "type": "input_audio_buffer.append",
+            "audio": audio_base64
+        }
+        
+        self.ws.send(json.dumps(message))
+    
+    def process_audio(self, audio_file):
+        """오디오 파일 처리 및 전송"""
+        if not self.is_connected:
+            return "WebSocket이 연결되지 않았습니다.", ""
+        
+        try:
+            # 오디오 파일 읽기
+            with wave.open(audio_file, 'rb') as wf:
+                # 오디오를 24kHz PCM16으로 변환 필요
+                audio_data = wf.readframes(wf.getnframes())
+                
+            # 오디오 데이터를 청크로 나누어 전송
+            chunk_size = 4096
+            for i in range(0, len(audio_data), chunk_size):
+                chunk = audio_data[i:i+chunk_size]
+                self.send_audio_chunk(chunk)
             
-            <button
-              onClick={swapLanguages}
-              className="mt-6 p-2 hover:bg-gray-100 rounded-lg"
-            >
-              <Globe className="w-6 h-6" />
-            </button>
+            # 오디오 버퍼 커밋
+            commit_message = {"type": "input_audio_buffer.commit"}
+            self.ws.send(json.dumps(commit_message))
             
-            <div className="flex-1">
-              <label className="block text-sm font-medium mb-2">출력 언어</label>
-              <select
-                value={targetLanguage}
-                onChange={(e) => setTargetLanguage(e.target.value)}
-                className="w-full p-2 border rounded-lg"
-              >
-                <option value="en">영어</option>
-                <option value="ko">한국어</option>
-              </select>
-            </div>
-          </div>
-        </div>
-
-        {/* 녹음 컨트롤 */}
-        <div className="bg-white rounded-lg shadow-md p-6 mb-6">
-          <div className="flex flex-col items-center">
-            <button
-              onClick={toggleRecording}
-              disabled={!isConnected}
-              className={`p-6 rounded-full transition-colors ${
-                isRecording 
-                  ? 'bg-red-500 hover:bg-red-600' 
-                  : 'bg-blue-500 hover:bg-blue-600 disabled:bg-gray-400'
-              } text-white`}
-            >
-              {isRecording ? (
-                <MicOff className="w-8 h-8" />
-              ) : (
-                <Mic className="w-8 h-8" />
-              )}
-            </button>
-            <p className="mt-4 text-sm text-gray-600">
-              {isRecording ? '녹음 중... 클릭하여 중지' : '클릭하여 녹음 시작'}
-            </p>
-          </div>
-        </div>
-
-        {/* 결과 표시 */}
-        <div className="bg-white rounded-lg shadow-md p-6 mb-6">
-          <h3 className="text-lg font-semibold mb-4">번역 결과</h3>
-          
-          <div className="space-y-4">
-            <div>
-              <label className="block text-sm font-medium mb-2">원본 텍스트</label>
-              <div className="p-4 bg-gray-50 rounded-lg min-h-[80px]">
-                {transcript || <span className="text-gray-400">음성 입력을 기다리는 중...</span>}
-              </div>
-            </div>
+            # 전사 및 번역 결과 대기
+            transcript = ""
+            translation = ""
             
-            <div>
-              <label className="block text-sm font-medium mb-2">번역된 텍스트</label>
-              <div className="p-4 bg-blue-50 rounded-lg min-h-[80px]">
-                {translation || <span className="text-gray-400">번역 결과가 여기에 표시됩니다...</span>}
-              </div>
-            </div>
-          </div>
-        </div>
-
-        {/* 로그 */}
-        <div className="bg-white rounded-lg shadow-md p-6">
-          <h3 className="text-lg font-semibold mb-4">활동 로그</h3>
-          <div className="h-48 overflow-y-auto bg-gray-50 rounded-lg p-4 text-sm">
-            {logs.length === 0 ? (
-              <p className="text-gray-400">로그가 여기에 표시됩니다...</p>
-            ) : (
-              logs.map((log, index) => (
-                <div
-                  key={index}
-                  className={`mb-2 ${
-                    log.type === 'error' ? 'text-red-600' :
-                    log.type === 'success' ? 'text-green-600' :
-                    log.type === 'warning' ? 'text-yellow-600' :
-                    'text-gray-700'
-                  }`}
-                >
-                  <span className="text-gray-500">[{log.timestamp}]</span> {log.message}
-                </div>
-              ))
-            )}
-          </div>
-        </div>
-
-        {/* 오디��� 엘리먼트 (숨김) */}
-        <audio ref={audioElRef} autoPlay style={{ display: 'none' }} />
-
-        {/* 사용 안내 */}
-        <div className="mt-6 p-4 bg-yellow-50 rounded-lg">
-          <h4 className="font-semibold text-yellow-800 mb-2">⚠️ 중요 안내</h4>
-          <ul className="text-sm text-yellow-700 space-y-1">
-            <li>• 이 애플리케이션을 사용하려면 서버에서 ephemeral key를 생성하는 엔드포인트가 필요합니다.</li>
-            <li>• OpenAI API 키가 필요하며, 클라이언트 측에서 직접 사용하면 안 됩니다.</li>
-            <li>• 실제 구현 시 주석 처리된 API 연결 코드를 활성화해야 합니다.</li>
-            <li>• 마이크 권한이 필요합니다.</li>
-          </ul>
-        </div>
-      </div>
-    </div>
-  );
-};
-
-export default RealtimeVoiceTranslator;
+            # 타임아웃 설정 (10초)
+            import time
+            timeout = 10
+            start_time = time.time()
+            
+            while time.time() - start_time < timeout:
+                # 전사 결과 확인
+                try:
+                    transcript = self.transcript_queue.get(timeout=0.1)
+                except queue.Empty:
+                    pass
+                
+                # 번역 결과 확인
+                try:
+                    while not self.translation_queue.empty():
+                        translation += self.translation_queue.get()
+                except queue.Empty:
+                    pass
+                
+                if transcript and translation:
+                    break
+            
+            return transcript, translation
+            
+        except Exception as e:
+            return f"오류: {str(e)}", ""
+    
+    def disconnect(self):
+        """WebSocket 연결 종료"""
+        if self.ws:
+            self.ws.close()
+        self.is_connected = False
+        return "연결 종료됨"
+
+# Gradio 인터페이스 생성
+def create_interface():
+    translator = RealtimeTranslator()
+    
+    def connect():
+        if not translator.api_key:
+            return "API 키가 설정되지 않았습니다. 환경 변수 OPENAI_API_KEY를 설정하세요.", gr.update(value=False)
+        result = translator.connect_websocket()
+        return result, gr.update(value=translator.is_connected)
+    
+    def disconnect():
+        result = translator.disconnect()
+        return result, gr.update(value=False)
+    
+    def translate_audio(audio_file, source_lang, target_lang):
+        if not audio_file:
+            return "오디오 파일을 선택하세요.", "", None
+        
+        translator.source_lang = source_lang
+        translator.target_lang = target_lang
+        
+        transcript, translation = translator.process_audio(audio_file)
+        
+        # 오디오 응답 처리 (현재는 텍스트만 반환)
+        return transcript, translation, None
+    
+    def swap_languages(source, target):
+        return target, source
+    
+    with gr.Blocks(title="실시간 음성 번역기") as demo:
+        gr.Markdown("# 🎙️ OpenAI Realtime API 음성 번역기")
+        gr.Markdown("실시간으로 음성을 전사하고 번역합니다.")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 연결 상태")
+                connection_status = gr.Checkbox(label="연결됨", value=False, interactive=False)
+                connect_btn = gr.Button("연결", variant="primary")
+                disconnect_btn = gr.Button("연결 종료", variant="secondary")
+                status_text = gr.Textbox(label="상태 메시지", value="연결되지 않음")
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                gr.Markdown("### 언어 설정")
+                with gr.Row():
+                    source_lang = gr.Dropdown(
+                        choices=[("한국어", "ko"), ("영어", "en"), ("일본어", "ja"), 
+                                ("중국어", "zh"), ("스페인어", "es"), ("프랑스어", "fr")],
+                        value="ko",
+                        label="입력 언어"
+                    )
+                    swap_btn = gr.Button("↔️", scale=0)
+                    target_lang = gr.Dropdown(
+                        choices=[("한국어", "ko"), ("영어", "en"), ("일본어", "ja"), 
+                                ("중국어", "zh"), ("스페인어", "es"), ("프랑스어", "fr")],
+                        value="en",
+                        label="출력 언어"
+                    )
+        
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### 음성 입력")
+                audio_input = gr.Audio(
+                    source="microphone",
+                    type="filepath",
+                    label="녹음하기"
+                )
+                translate_btn = gr.Button("번역하기", variant="primary")
+        
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### 결과")
+                transcript_output = gr.Textbox(
+                    label="전사된 텍스트",
+                    placeholder="음성 전사 결과가 여기에 표시됩니다...",
+                    lines=3
+                )
+                translation_output = gr.Textbox(
+                    label="번역된 텍스트",
+                    placeholder="번역 결과가 여기에 표시됩니다...",
+                    lines=3
+                )
+                audio_output = gr.Audio(
+                    label="번역된 음성",
+                    type="filepath"
+                )
+        
+        # 이벤트 핸들러
+        connect_btn.click(
+            fn=connect,
+            outputs=[status_text, connection_status]
+        )
+        
+        disconnect_btn.click(
+            fn=disconnect,
+            outputs=[status_text, connection_status]
+        )
+        
+        swap_btn.click(
+            fn=swap_languages,
+            inputs=[source_lang, target_lang],
+            outputs=[source_lang, target_lang]
+        )
+        
+        translate_btn.click(
+            fn=translate_audio,
+            inputs=[audio_input, source_lang, target_lang],
+            outputs=[transcript_output, translation_output, audio_output]
+        )
+        
+        gr.Markdown("""
+        ### 📝 사용 방법
+        1. **연결** 버튼을 클릭하여 OpenAI Realtime API에 연결합니다.
+        2. 입력 언어와 출력 언어를 선택합니다.
+        3. 마이크 버튼을 클릭하여 음성을 녹음합니다.
+        4. **번역하기** 버튼을 클릭하면 전사 및 번역이 진행됩니다.
+        
+        ### ⚠️ 주의사항
+        - 환경 변수 `OPENAI_API_KEY`가 설정되어 있어야 합니다.
+        - 긴 오디오의 경우 처리 시간이 오래 걸릴 수 있습니다.
+        """)
+    
+    return demo
+
+# 실행
+if __name__ == "__main__":
+    # 필요한 패키지 설치 안내
+    print("""
+    필요한 패키지:
+    pip install gradio websocket-client pyaudio wave numpy
+    
+    환경 변수 설정:
+    export OPENAI_API_KEY="your-api-key-here"
+    """)
+    
+    demo = create_interface()
+    demo.launch(share=True)