Upload 8 files

.env

@@ -0,0 +1,7 @@
+# Together AI 配置
+TOGETHER_API_KEY=520fa4af1471aafb9949110e98dde9232c629fc8e51e81a830a85f791c1cfe64
+
+# NocoDB 配置
+NOCODB_API_KEY=niITP3GMp_241YJeZvjKQtw4Wp8ltnwgUtUcF2Q8
+NOCODB_URL=https://app.nocodb.com
+NOCODB_PROJECT_ID=p1lg93fo8zt1jsg

app.py

@@ -0,0 +1,1025 @@
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from datetime import datetime, timedelta
+import hashlib
+import uuid
+import time
+from config import APP_TITLE, APP_DESCRIPTION, GAME_CONFIG
+from database.nocodb import nocodb_client
+from llm.together import together_client
+
+# 设置页面配置
+st.set_page_config(
+    page_title=APP_TITLE,
+    page_icon="⚔️",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# 自定义CSS样式
+st.markdown("""
+<style>
+    .main {
+        background-color: #f0f2f6;
+    }
+    .stButton>button {
+        background-color: #4CAF50;
+        color: white;
+        border-radius: 5px;
+        padding: 10px 20px;
+        font-weight: bold;
+        transition: all 0.3s ease;
+    }
+    .stButton>button:hover {
+        background-color: #45a049;
+        transform: translateY(-2px);
+        box-shadow: 0 2px 5px rgba(0,0,0,0.2);
+    }
+    .character-card {
+        background-color: white;
+        padding: 20px;
+        border-radius: 10px;
+        box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+        transition: all 0.3s ease;
+    }
+    .character-card:hover {
+        transform: translateY(-5px);
+        box-shadow: 0 5px 15px rgba(0,0,0,0.2);
+    }
+    .battle-log {
+        background-color: #fff3cd;
+        padding: 15px;
+        border-radius: 5px;
+        margin: 10px 0;
+        border-left: 5px solid #ffc107;
+    }
+    .success-message {
+        color: #28a745;
+        font-weight: bold;
+        padding: 10px;
+        border-radius: 5px;
+        background-color: #d4edda;
+    }
+    .error-message {
+        color: #dc3545;
+        font-weight: bold;
+        padding: 10px;
+        border-radius: 5px;
+        background-color: #f8d7da;
+    }
+    .sidebar-content {
+        padding: 20px;
+        background-color: #f8f9fa;
+        border-radius: 10px;
+        margin-bottom: 20px;
+    }
+    .tab-content {
+        padding: 20px;
+        background-color: white;
+        border-radius: 10px;
+        box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+    }
+    .stat-value {
+        font-size: 1.2em;
+        font-weight: bold;
+        color: #2c3e50;
+    }
+    .class-badge {
+        padding: 5px 10px;
+        border-radius: 15px;
+        font-size: 0.9em;
+        font-weight: bold;
+    }
+    .warrior { background-color: #e74c3c; color: white; }
+    .mage { background-color: #3498db; color: white; }
+    .rogue { background-color: #2ecc71; color: white; }
+    .priest { background-color: #9b59b6; color: white; }
+    .archer { background-color: #f1c40f; color: white; }
+</style>
+""", unsafe_allow_html=True)
+
+# 初始化会话状态
+if 'user_id' not in st.session_state:
+    st.session_state.user_id = None
+if 'character' not in st.session_state:
+    st.session_state.character = None
+if 'characters' not in st.session_state:
+    st.session_state.characters = []
+if 'is_logged_in' not in st.session_state:
+    st.session_state.is_logged_in = False
+if 'current_tab' not in st.session_state:
+    st.session_state.current_tab = "角色信息"
+
+def hash_password(password: str) -> str:
+    """对密码进行哈希处理"""
+    return hashlib.sha256(password.encode()).hexdigest()
+
+def login_user(username: str, password: str) -> bool:
+    """用户登录"""
+    try:
+        users = nocodb_client.get_records("users", {
+            "where": f"(username,eq,{username})"
+        })
+        if users and users[0]["password"] == hash_password(password):
+            st.session_state.user_id = users[0]["Id"]
+            st.session_state.is_logged_in = True
+            # 加载用户的所有角色
+            characters = nocodb_client.get_records("characters", {
+                "where": f"(user_id,eq,{users[0]['Id']})"
+            })
+            st.session_state.characters = characters
+            return True
+    except Exception as e:
+        st.error(f"登录失败: {str(e)}")
+    return False
+
+def register_user(username: str, password: str) -> bool:
+    """用户注册"""
+    try:
+        # 检查用户名是否已存在
+        existing_users = nocodb_client.get_records("users", {
+            "where": f"(username,eq,{username})"
+        })
+        if existing_users:
+            st.error("用户名已存在")
+            return False
+        
+        # 创建新用户
+        user = {
+            "username": username,
+            "password": hash_password(password),
+            "created_time": datetime.now().isoformat()
+        }
+        result = nocodb_client.create_record("users", user)
+        return True
+    except Exception as e:
+        st.error(f"注册失败: {str(e)}")
+        return False
+
+def load_character(character_id: str) -> None:
+    """加载指定角色"""
+    try:
+        characters = nocodb_client.get_records("characters", {
+            "where": f"(Id,eq,{character_id})"
+        })
+        if characters:
+            # 确保所有必需的属性都存在
+            character = characters[0]
+            required_fields = {
+                'level': 1,
+                'EXP': 0,
+                'ATK': GAME_CONFIG["base_stats"]["ATK"],
+                'DEF': GAME_CONFIG["base_stats"]["DEF"],
+                'MAG': GAME_CONFIG["base_stats"]["MAG"],
+                'DEX': GAME_CONFIG["base_stats"]["DEX"],
+                'LUK': GAME_CONFIG["base_stats"]["LUK"]
+            }
+            
+            # 如果缺少任何必需字段，使用默认值
+            for field, default_value in required_fields.items():
+                if field not in character:
+                    character[field] = default_value
+                    # 更新数据库中的记录
+                    nocodb_client.update_record("characters", character_id, {field: default_value})
+            
+            st.session_state.character = character
+            st.rerun()
+    except Exception as e:
+        st.error(f"加载角色失败: {str(e)}")
+
+def create_character(name: str, character_class: str) -> bool:
+    """创建新角色"""
+    try:
+        # 获取职业基础属性
+        class_stats = GAME_CONFIG["class_base_stats"][character_class]
+        
+        # 确保所有必需的字段都有默认值
+        character = {
+            "user_id": int(st.session_state.user_id),
+            "name": name,
+            "class": character_class,
+            "level": 1,
+            "EXP": 0,
+            "ATK": class_stats["ATK"],
+            "DEF": class_stats["DEF"],
+            "MAG": class_stats["MAG"],
+            "DEX": class_stats["DEX"],
+            "LUK": class_stats["LUK"],
+            "created_time": datetime.now().isoformat(),
+            "last_login": datetime.now().isoformat()
+        }
+        
+        result = nocodb_client.create_record("characters", character)
+        if result:
+            # 确保返回的结果包含所有必需的字段
+            for field, value in character.items():
+                if field not in result:
+                    result[field] = value
+            st.session_state.character = result
+            return True
+        return False
+    except Exception as e:
+        st.error(f"创建角色失败: {str(e)}")
+        return False
+
+def update_character_stats(character_id: str, stats: dict) -> bool:
+    """更新角色属性"""
+    try:
+        nocodb_client.update_record("characters", character_id, stats)
+        return True
+    except Exception as e:
+        st.error(f"更新属性失败: {str(e)}")
+        return False
+
+def get_class_badge(character_class: str) -> str:
+    """获取职业徽章样式"""
+    class_styles = {
+        "战士": "warrior",
+        "法师": "mage",
+        "刺客": "rogue",
+        "牧师": "priest",
+        "弓箭手": "archer"
+    }
+    return f'<span class="class-badge {class_styles.get(character_class, "")}">{character_class}</span>'
+
+def create_character_stats_chart(character):
+    """创建角色属性雷达图"""
+    stats = {
+        '属性': ['攻击力', '防御力', '魔法力', '敏捷', '幸运'],
+        '数值': [
+            character['ATK'],
+            character['DEF'],
+            character['MAG'],
+            character['DEX'],
+            character['LUK']
+        ]
+    }
+    
+    fig = go.Figure()
+    fig.add_trace(go.Scatterpolar(
+        r=stats['数值'],
+        theta=stats['属性'],
+        fill='toself',
+        name='当前属性'
+    ))
+    
+    # 添加职业基准线
+    class_stats = GAME_CONFIG["class_base_stats"][character['class']]
+    base_stats = [
+        class_stats['ATK'],
+        class_stats['DEF'],
+        class_stats['MAG'],
+        class_stats['DEX'],
+        class_stats['LUK']
+    ]
+    
+    fig.add_trace(go.Scatterpolar(
+        r=base_stats,
+        theta=stats['属性'],
+        fill='toself',
+        name='职业基准'
+    ))
+    
+    fig.update_layout(
+        polar=dict(
+            radialaxis=dict(
+                visible=True,
+                range=[0, max(max(stats['数值']), max(base_stats)) * 1.2]
+            )),
+        showlegend=True,
+        title='角色属性雷达图'
+    )
+    
+    return fig
+
+def create_level_progress_chart(character):
+    """创建等级进度条"""
+    # 计算升级所需经验值（示例：每级需要1000经验）
+    exp_needed = character['level'] * 1000
+    progress = (character['EXP'] / exp_needed) * 100
+    
+    fig = go.Figure(go.Indicator(
+        mode="gauge+number",
+        value=progress,
+        title={'text': f"升级进度 (Lv.{character['level']})"},
+        gauge={
+            'axis': {'range': [0, 100]},
+            'bar': {'color': "darkblue"},
+            'steps': [
+                {'range': [0, 100], 'color': "lightgray"}
+            ],
+            'threshold': {
+                'line': {'color': "red", 'width': 4},
+                'thickness': 0.75,
+                'value': 100
+            }
+        }
+    ))
+    
+    fig.update_layout(
+        height=200,
+        margin=dict(l=20, r=20, t=50, b=20)
+    )
+    
+    return fig
+
+def create_friend_ranking_table(character, available_opponents):
+    """创建好友排行榜表格"""
+    try:
+        # 确保当前角色的所有属性都有值
+        current_char = {
+            'name': character['name'],
+            'level': character.get('level', 1),
+            'ATK': character.get('ATK', 10),
+            'DEF': character.get('DEF', 10),
+            'MAG': character.get('MAG', 10),
+            'DEX': character.get('DEX', 10),
+            'LUK': character.get('LUK', 10),
+            'class': character['class'],
+            'username': '你'
+        }
+        current_char['total_stats'] = current_char['ATK'] + current_char['DEF'] + current_char['MAG'] + current_char['DEX'] + current_char['LUK']
+        
+        # 确保所有对手的属性都有值
+        for opp in available_opponents:
+            opp['ATK'] = opp.get('ATK', 10)
+            opp['DEF'] = opp.get('DEF', 10)
+            opp['MAG'] = opp.get('MAG', 10)
+            opp['DEX'] = opp.get('DEX', 10)
+            opp['LUK'] = opp.get('LUK', 10)
+            opp['level'] = opp.get('level', 1)
+            opp['total_stats'] = opp['ATK'] + opp['DEF'] + opp['MAG'] + opp['DEX'] + opp['LUK']
+        
+        all_chars = available_opponents + [current_char]
+        
+        # 按总属性值排序
+        sorted_chars = sorted(all_chars, key=lambda x: x['total_stats'], reverse=True)
+        
+        # 创建表格数据
+        table_data = []
+        for i, char in enumerate(sorted_chars, 1):
+            table_data.append({
+                "排名": i,
+                "角色名": char['name'],
+                "职业": char['class'],
+                "等级": char['level'],
+                "攻击力": char['ATK'],
+                "防御力": char['DEF'],
+                "魔法力": char['MAG'],
+                "敏捷": char['DEX'],
+                "幸运": char['LUK'],
+                "总属性": char['total_stats'],
+                "玩家": char['username']
+            })
+        
+        # 创建DataFrame
+        df = pd.DataFrame(table_data)
+        
+        return df
+    except Exception as e:
+        st.error(f"创建排行榜失败: {str(e)}")
+        return None
+
+# 添加请求限制装饰器
+def rate_limit(max_requests=10, time_window=60):
+    """请求限制装饰器"""
+    last_reset = time.time()
+    request_count = 0
+    
+    def decorator(func):
+        def wrapper(*args, **kwargs):
+            nonlocal last_reset, request_count
+            current_time = time.time()
+            
+            # 重置计数器
+            if current_time - last_reset >= time_window:
+                last_reset = current_time
+                request_count = 0
+            
+            # 检查是否超过限制
+            if request_count >= max_requests:
+                time.sleep(time_window - (current_time - last_reset))
+                last_reset = time.time()
+                request_count = 0
+            
+            request_count += 1
+            return func(*args, **kwargs)
+        return wrapper
+    return decorator
+
+# 添加重试机制
+def retry_on_error(max_retries=3, delay=1):
+    """重试装饰器"""
+    def decorator(func):
+        def wrapper(*args, **kwargs):
+            for attempt in range(max_retries):
+                try:
+                    return func(*args, **kwargs)
+                except Exception as e:
+                    if "429" in str(e):
+                        if attempt < max_retries - 1:
+                            time.sleep(delay * (attempt + 1))
+                            continue
+                    raise e
+            return func(*args, **kwargs)
+        return wrapper
+    return decorator
+
+# 修改获取好友列表的函数
+@rate_limit(max_requests=10, time_window=60)
+@retry_on_error(max_retries=3, delay=2)
+def get_available_opponents(current_user_id):
+    """获取可用的对手列表"""
+    try:
+        # 使用缓存机制获取所有用户和角色数据
+        users = nocodb_client.get_records("users")
+        if not users:
+            return []
+            
+        # 获取所有角色数据（一次性获取）
+        all_characters = nocodb_client.get_records("characters")
+        
+        # 在内存中过滤和处理数据
+        available_opponents = []
+        for user in users:
+            if user["Id"] != current_user_id:  # 排除自己
+                # 在内存中过滤该用户的角色
+                user_characters = [char for char in all_characters if char.get("user_id") == user["Id"]]
+                if user_characters:
+                    for char in user_characters:
+                        available_opponents.append({
+                            "id": char["Id"],
+                            "name": char["name"],
+                            "class": char["class"],
+                            "level": char.get("level", 1),
+                            "username": user["username"],
+                            "ATK": char.get("ATK", 10),
+                            "DEF": char.get("DEF", 10),
+                            "MAG": char.get("MAG", 10),
+                            "DEX": char.get("DEX", 10),
+                            "LUK": char.get("LUK", 10)
+                        })
+        return available_opponents
+    except Exception as e:
+        st.error(f"获取好友列表失败: {str(e)}")
+        return []
+
+# 修改对战记录获取逻辑
+def get_battle_records(character_id):
+    """获取对战记录（带缓存）"""
+    try:
+        # 添加错误处理和重试逻辑
+        max_retries = 3
+        retry_delay = 2
+        
+        for attempt in range(max_retries):
+            try:
+                battles = nocodb_client.get_records("battles", {
+                    "where": f"(attacker,eq,{character_id})"
+                })
+                return battles[-5:] if battles else []  # 只返回最近5场对战
+            except Exception as e:
+                if "429" in str(e) and attempt < max_retries - 1:
+                    time.sleep(retry_delay * (attempt + 1))
+                    continue
+                raise e
+    except Exception as e:
+        st.error(f"获取对战记录失败: {str(e)}")
+        return []
+
+# 修改Boss挑战记录获取逻辑
+def get_boss_challenge_records(character_id):
+    """获取Boss挑战记录（带缓存）"""
+    try:
+        # 添加错误处理和重试逻辑
+        max_retries = 3
+        retry_delay = 2
+        
+        for attempt in range(max_retries):
+            try:
+                challenges = nocodb_client.get_records("boss_challenges", {
+                    "where": f"(team,like,{character_id})"
+                })
+                return challenges[-5:] if challenges else []  # 只返回最近5场挑战
+            except Exception as e:
+                if "429" in str(e) and attempt < max_retries - 1:
+                    time.sleep(retry_delay * (attempt + 1))
+                    continue
+                raise e
+    except Exception as e:
+        st.error(f"获取挑战记录失败: {str(e)}")
+        return []
+
+# 侧边栏
+with st.sidebar:
+    st.title("⚔️ RPG冒险游戏")
+    
+    if not st.session_state.is_logged_in:
+        with st.container():
+            st.markdown('<div class="sidebar-content">', unsafe_allow_html=True)
+            tab1, tab2 = st.tabs(["登录", "注册"])
+            
+            with tab1:
+                with st.form("login_form"):
+                    login_username = st.text_input("用户名")
+                    login_password = st.text_input("密码", type="password")
+                    if st.form_submit_button("登录", use_container_width=True):
+                        if login_user(login_username, login_password):
+                            st.success("登录成功！")
+                            st.rerun()
+            
+            with tab2:
+                with st.form("register_form"):
+                    reg_username = st.text_input("新用户名")
+                    reg_password = st.text_input("新密码", type="password")
+                    reg_confirm = st.text_input("确认密码", type="password")
+                    if st.form_submit_button("注册", use_container_width=True):
+                        if reg_password == reg_confirm:
+                            if register_user(reg_username, reg_password):
+                                st.success("注册成功！请登录")
+                        else:
+                            st.error("两次输入的密码不一致")
+            st.markdown('</div>', unsafe_allow_html=True)
+    else:
+        with st.container():
+            st.markdown('<div class="sidebar-content">', unsafe_allow_html=True)
+            st.success(f"欢迎回来！")
+            
+            # 角色选择
+            if st.session_state.characters:
+                st.markdown("### 选择角色")
+                character_names = [f"{char['name']} ({char['class']})" for char in st.session_state.characters]
+                selected_character = st.selectbox(
+                    "选择要使用的角色",
+                    character_names,
+                    index=0 if not st.session_state.character else character_names.index(f"{st.session_state.character['name']} ({st.session_state.character['class']})")
+                )
+                if selected_character:
+                    selected_id = st.session_state.characters[character_names.index(selected_character)]["Id"]
+                    if not st.session_state.character or st.session_state.character["Id"] != selected_id:
+                        load_character(selected_id)
+            
+            # 功能导航
+            st.markdown("### 功能导航")
+            tabs = ["角色信息", "角色培养", "PVP对战", "Boss挑战"]
+            selected_tab = st.radio("选择功能", tabs, index=tabs.index(st.session_state.current_tab))
+            st.session_state.current_tab = selected_tab
+            
+            if st.button("退出登录", use_container_width=True):
+                st.session_state.is_logged_in = False
+                st.session_state.user_id = None
+                st.session_state.character = None
+                st.session_state.characters = []
+                st.rerun()
+            st.markdown('</div>', unsafe_allow_html=True)
+    
+    # 模型选择
+    with st.container():
+        st.markdown('<div class="sidebar-content">', unsafe_allow_html=True)
+        st.markdown("### AI模型设置")
+        try:
+            models = together_client.get_available_models()
+            if models:
+                model_names = [model["name"] for model in models]
+                selected_model = st.selectbox(
+                    "选择AI模型",
+                    model_names,
+                    index=0
+                )
+                together_client.set_model(selected_model)
+        except Exception as e:
+            st.warning(f"获取模型列表失败: {str(e)}")
+        st.markdown('</div>', unsafe_allow_html=True)
+
+# 主界面
+if not st.session_state.is_logged_in:
+    st.markdown("""
+    <div style='text-align: center; padding: 50px;'>
+        <h1>欢迎来到RPG冒险游戏</h1>
+        <p>请先登录或注册以开始游戏</p>
+    </div>
+    """, unsafe_allow_html=True)
+else:
+    # 检查NocoDB连接
+    try:
+        nocodb_client.get_records("characters")
+    except Exception as e:
+        st.error(f"无法连接到NocoDB数据库: {str(e)}")
+        st.stop()
+
+    # 根据选择的标签页显示不同内容
+    if st.session_state.current_tab == "角色信息":
+        if not st.session_state.character:
+            st.markdown("""
+            <div style='text-align: center;'>
+                <h2>创建你的角色</h2>
+                <p>选择一个职业，开始你的冒险之旅！</p>
+            </div>
+            """, unsafe_allow_html=True)
+            
+            with st.form("character_creation"):
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    name = st.text_input("角色名称")
+                    character_class = st.selectbox(
+                        "选择职业",
+                        GAME_CONFIG["classes"]
+                    )
+                
+                with col2:
+                    st.markdown("### 职业介绍")
+                    class_descriptions = {
+                        "战士": "擅长近战，拥有较高的攻击力和防御力",
+                        "法师": "精通魔法，拥有强大的魔法攻击力",
+                        "刺客": "敏捷灵活，擅长暴击和闪避",
+                        "牧师": "精通治疗和辅助魔法",
+                        "弓箭手": "远程攻击专家，拥有较高的命中率"
+                    }
+                    st.write(class_descriptions[character_class])
+                
+                if st.form_submit_button("创建角色", use_container_width=True):
+                    if name:
+                        if create_character(name, character_class):
+                            st.success("角色创建成功！")
+                            st.rerun()
+                    else:
+                        st.warning("请输入角色名称")
+        else:
+            # 角色基本信息卡片
+            st.markdown(f"""
+            <div class='character-card'>
+                <h2>{st.session_state.character['name']} {get_class_badge(st.session_state.character['class'])}</h2>
+                <div style='display: flex; justify-content: space-between;'>
+                    <div>
+                        <p>ID：<span class='stat-value'>{st.session_state.character['Id']}</span></p>
+                        <p>等级：<span class='stat-value'>{st.session_state.character['level']}</span></p>
+                        <p>经验值：<span class='stat-value'>{st.session_state.character['EXP']}</span></p>
+                    </div>
+                    <div>
+                        <p>攻击力：<span class='stat-value'>{st.session_state.character['ATK']}</span></p>
+                        <p>防御力：<span class='stat-value'>{st.session_state.character['DEF']}</span></p>
+                        <p>魔法力：<span class='stat-value'>{st.session_state.character['MAG']}</span></p>
+                        <p>敏捷：<span class='stat-value'>{st.session_state.character['DEX']}</span></p>
+                        <p>幸运：<span class='stat-value'>{st.session_state.character['LUK']}</span></p>
+                    </div>
+                </div>
+            </div>
+            """, unsafe_allow_html=True)
+            
+            # 添加属性雷达图
+            st.plotly_chart(create_character_stats_chart(st.session_state.character), use_container_width=True)
+            
+            # 添加等级进度条
+            st.plotly_chart(create_level_progress_chart(st.session_state.character), use_container_width=True)
+            
+            # 添加职业特点说明
+            st.markdown("### 职业特点")
+            class_descriptions = {
+                "战士": "擅长近战，拥有较高的攻击力和防御力，是团队中的主要输出和防御力量。",
+                "法师": "精通魔法，拥有强大的魔法攻击力，但防御较弱，需要队友保护。",
+                "刺客": "敏捷灵活，擅长暴击和闪避，是团队中的突袭手。",
+                "牧师": "精通治疗和辅助魔法，是团队中的重要支援角色。",
+                "弓箭手": "远程攻击专家，拥有较高的命中率，适合风筝战术。"
+            }
+            st.info(class_descriptions[st.session_state.character['class']])
+
+    elif st.session_state.current_tab == "角色培养":
+        if not st.session_state.character:
+            st.warning("请先创建角色")
+        else:
+            st.markdown("""
+            <div style='text-align: center;'>
+                <h2>角色培养</h2>
+                <p>通过每日登录和属性点分配来提升你的角色！</p>
+            </div>
+            """, unsafe_allow_html=True)
+            
+            try:
+                # 检查每日登录奖励
+                last_login = st.session_state.character.get("last_login")
+                if last_login:
+                    try:
+                        # 尝试解析日期时间字符串
+                        if isinstance(last_login, str):
+                            last_login_dt = datetime.fromisoformat(last_login)
+                            if datetime.now() - last_login_dt > timedelta(days=1):
+                                # 更新等级和经验值
+                                new_level = st.session_state.character["level"] + 1
+                                new_exp = st.session_state.character["EXP"] + 100  # 每次升级增加100经验值
+                                
+                                # 更新角色数据
+                                update_data = {
+                                    "level": new_level,
+                                    "EXP": new_exp,
+                                    "last_login": datetime.now().isoformat()
+                                }
+                                
+                                if update_character_stats(st.session_state.character["Id"], update_data):
+                                    st.session_state.character["level"] = new_level
+                                    st.session_state.character["EXP"] = new_exp
+                                    st.session_state.character["last_login"] = datetime.now().isoformat()
+                                    
+                                    st.markdown(f"""
+                                    <div class='success-message'>
+                                        获得每日登录奖励：
+                                        <br>等级提升：{new_level-1} → {new_level}
+                                        <br>经验值增加：+100
+                                        <br>获得5点属性点！
+                                    </div>
+                                    """, unsafe_allow_html=True)
+                    except (ValueError, TypeError):
+                        # 如果解析失败，忽略日期检查
+                        pass
+                
+                # 属性点分配
+                st.markdown("### 属性点分配")
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    atk_points = st.number_input("攻击力", min_value=0, value=0)
+                    def_points = st.number_input("防御力", min_value=0, value=0)
+                    mag_points = st.number_input("魔法力", min_value=0, value=0)
+                
+                with col2:
+                    dex_points = st.number_input("敏捷", min_value=0, value=0)
+                    luk_points = st.number_input("幸运", min_value=0, value=0)
+                
+                if st.button("确认加点", use_container_width=True):
+                    total_points = atk_points + def_points + mag_points + dex_points + luk_points
+                    if total_points <= GAME_CONFIG["max_daily_points"]:
+                        # 更新角色属性
+                        st.session_state.character["ATK"] += atk_points
+                        st.session_state.character["DEF"] += def_points
+                        st.session_state.character["MAG"] += mag_points
+                        st.session_state.character["DEX"] += dex_points
+                        st.session_state.character["LUK"] += luk_points
+                        
+                        if update_character_stats(st.session_state.character["Id"], {
+                            "ATK": st.session_state.character["ATK"],
+                            "DEF": st.session_state.character["DEF"],
+                            "MAG": st.session_state.character["MAG"],
+                            "DEX": st.session_state.character["DEX"],
+                            "LUK": st.session_state.character["LUK"]
+                        }):
+                            st.success("属性点分配成功！")
+                    else:
+                        st.warning(f"每日最多只能分配{GAME_CONFIG['max_daily_points']}点属性点")
+            except Exception as e:
+                st.error(f"角色培养系统出错: {str(e)}")
+
+    elif st.session_state.current_tab == "PVP对战":
+        if not st.session_state.character:
+            st.warning("请先创建角色")
+        else:
+            st.markdown("""
+            <div style='text-align: center;'>
+                <h2>PVP对战</h2>
+                <p>与其他玩家进行对战，展示你的实力！</p>
+            </div>
+            """, unsafe_allow_html=True)
+            
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                # 添加好友挑战选项
+                st.markdown("### 好友挑战")
+                try:
+                    # 使用新的获取对手函数
+                    available_opponents = get_available_opponents(st.session_state.user_id)
+                    
+                    if available_opponents:
+                        # 显示排行榜
+                        st.markdown("### 好友排行榜")
+                        ranking_table = create_friend_ranking_table(st.session_state.character, available_opponents)
+                        if ranking_table is not None:
+                            # 使用Streamlit的表格显示功能
+                            st.dataframe(
+                                ranking_table,
+                                use_container_width=True,
+                                hide_index=True,
+                                column_config={
+                                    "排名": st.column_config.NumberColumn("排名", width="small"),
+                                    "角色名": st.column_config.TextColumn("角色名", width="medium"),
+                                    "职业": st.column_config.TextColumn("职业", width="small"),
+                                    "等级": st.column_config.NumberColumn("等级", width="small"),
+                                    "攻击力": st.column_config.NumberColumn("攻击力", width="small"),
+                                    "防御力": st.column_config.NumberColumn("防御力", width="small"),
+                                    "魔法力": st.column_config.NumberColumn("魔法力", width="small"),
+                                    "敏捷": st.column_config.NumberColumn("敏捷", width="small"),
+                                    "幸运": st.column_config.NumberColumn("幸运", width="small"),
+                                    "总属性": st.column_config.NumberColumn("总属性", width="small"),
+                                    "玩家": st.column_config.TextColumn("玩家", width="medium")
+                                }
+                            )
+                            
+                            # 高亮显示当前玩家的行
+                            current_player_row = ranking_table[ranking_table['角色名'] == st.session_state.character['name']]
+                            if not current_player_row.empty:
+                                st.markdown(f"""
+                                <div style='background-color: #FFD700; padding: 10px; border-radius: 5px; margin-top: 10px;'>
+                                    <strong>你的排名：第{current_player_row['排名'].iloc[0]}名</strong>
+                                </div>
+                                """, unsafe_allow_html=True)
+                        
+                        # 创建选择框
+                        opponent_options = [f"{opp['name']} ({opp['class']}) - 等级{opp['level']} - 玩家：{opp['username']}" for opp in available_opponents]
+                        selected_opponent = st.selectbox(
+                            "选择要挑战的好友",
+                            opponent_options,
+                            index=0
+                        )
+                        
+                        if st.button("挑战好友", use_container_width=True):
+                            selected_id = available_opponents[opponent_options.index(selected_opponent)]["id"]
+                            try:
+                                # 获取对手信息
+                                opponents = nocodb_client.get_records("characters", {
+                                    "where": f"(Id,eq,{selected_id})"
+                                })
+                                
+                                if opponents:
+                                    opponent = opponents[0]
+                                    # 生成对战剧情
+                                    battle_story = together_client.generate_battle_story(
+                                        st.session_state.character,
+                                        opponent
+                                    )
+                                    
+                                    # 保存对战记录
+                                    battle_record = {
+                                        "attacker": st.session_state.character["Id"],
+                                        "defender": opponent["Id"],
+                                        "battle_story": battle_story,
+                                        "created_time": datetime.now().isoformat()
+                                    }
+                                    nocodb_client.create_record("battles", battle_record)
+                                    
+                                    # 显示对战剧情
+                                    st.markdown("### 对战剧情")
+                                    st.markdown(f"""
+                                    <div class='battle-log'>
+                                        {battle_story}
+                                    </div>
+                                    """, unsafe_allow_html=True)
+                            except Exception as e:
+                                st.error(f"对战失败: {str(e)}")
+                    else:
+                        st.info("当前没有可挑战的好友")
+                except Exception as e:
+                    st.error(f"获取好友列表失败: {str(e)}")
+                
+                st.markdown("---")
+                st.markdown("### 直接挑战")
+                opponent_id = st.text_input("输入对手的ID")
+                if st.button("开始对战", use_container_width=True):
+                    if opponent_id:
+                        try:
+                            # 获取对手信息
+                            opponents = nocodb_client.get_records("characters", {
+                                "where": f"(Id,eq,{opponent_id})"
+                            })
+                            
+                            if opponents:
+                                opponent = opponents[0]
+                                # 生成对战剧情
+                                battle_story = together_client.generate_battle_story(
+                                    st.session_state.character,
+                                    opponent
+                                )
+                                
+                                # 保存对战记录
+                                battle_record = {
+                                    "attacker": st.session_state.character["Id"],
+                                    "defender": opponent["Id"],
+                                    "battle_story": battle_story,
+                                    "created_time": datetime.now().isoformat()
+                                }
+                                nocodb_client.create_record("battles", battle_record)
+                                
+                                # 显示对战剧情
+                                st.markdown("### 对战剧情")
+                                st.markdown(f"""
+                                <div class='battle-log'>
+                                    {battle_story}
+                                </div>
+                                """, unsafe_allow_html=True)
+                            else:
+                                st.warning("未找到对手")
+                        except Exception as e:
+                            st.error(f"对战失败: {str(e)}")
+                    else:
+                        st.warning("请输入对手的ID")
+            
+            with col2:
+                st.markdown("### 最近对战记录")
+                try:
+                    battles = get_battle_records(st.session_state.character["Id"])
+                    if battles:
+                        for battle in battles:  # 显示最近5场对战
+                            st.markdown(f"""
+                            <div class='battle-log'>
+                                <p>对战时间：{battle['created_time']}</p>
+                                <p>对战剧情：{battle['battle_story'][:100]}...</p>
+                            </div>
+                            """, unsafe_allow_html=True)
+                    else:
+                        st.info("暂无对战记录")
+                except Exception as e:
+                    st.error(f"获取对战记录失败: {str(e)}")
+
+    elif st.session_state.current_tab == "Boss挑战":
+        if not st.session_state.character:
+            st.warning("请先创建角色")
+        else:
+            st.markdown("""
+            <div style='text-align: center;'>
+                <h2>Boss挑战</h2>
+                <p>组队挑战强大的Boss，获取丰厚奖励！</p>
+            </div>
+            """, unsafe_allow_html=True)
+            
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                # 显示当前Boss信息
+                st.markdown("### 当前Boss")
+                for boss in GAME_CONFIG["bosses"]:
+                    st.markdown(f"""
+                    <div class='character-card'>
+                        <h3>{boss['name']}</h3>
+                        <p>攻击力：<span class='stat-value'>{boss['ATK']}</span></p>
+                        <p>防御力：<span class='stat-value'>{boss['DEF']}</span></p>
+                        <p>魔法力：<span class='stat-value'>{boss['MAG']}</span></p>
+                        <p>敏捷：<span class='stat-value'>{boss['DEX']}</span></p>
+                        <p>幸运：<span class='stat-value'>{boss['LUK']}</span></p>
+                    </div>
+                    """, unsafe_allow_html=True)
+                
+                # 组队挑战
+                team_member_ids = st.text_area("输入队友ID（每行一个）")
+                if st.button("开始挑战", use_container_width=True):
+                    if team_member_ids:
+                        try:
+                            # 获取队友信息
+                            team = [st.session_state.character]
+                            for id in team_member_ids.strip().split("\n"):
+                                members = nocodb_client.get_records("characters", {
+                                    "where": f"(Id,eq,{id})"
+                                })
+                                if members:
+                                    team.append(members[0])
+                            
+                            if len(team) > 1:
+                                # 生成Boss战剧情
+                                boss_story = together_client.generate_boss_story(team, GAME_CONFIG["bosses"][0])
+                                
+                                # 保存挑战记录
+                                challenge_record = {
+                                    "team": ",".join([str(member["Id"]) for member in team]),
+                                    "boss_id": 1,
+                                    "story": boss_story,
+                                    "created_time": datetime.now().isoformat()
+                                }
+                                nocodb_client.create_record("boss_challenges", challenge_record)
+                                
+                                # 显示挑战剧情
+                                st.markdown("### 挑战剧情")
+                                st.markdown(f"""
+                                <div class='battle-log'>
+                                    {boss_story}
+                                </div>
+                                """, unsafe_allow_html=True)
+                            else:
+                                st.warning("需要至少一名队友")
+                        except Exception as e:
+                            st.error(f"挑战失败: {str(e)}")
+                    else:
+                        st.warning("请输入队友ID")
+            
+            with col2:
+                st.markdown("### 最近挑战记录")
+                try:
+                    challenges = get_boss_challenge_records(st.session_state.character["Id"])
+                    if challenges:
+                        for challenge in challenges:  # 显示最近5场挑战
+                            st.markdown(f"""
+                            <div class='battle-log'>
+                                <p>挑战时间：{challenge['created_time']}</p>
+                                <p>挑战剧情：{challenge['story'][:100]}...</p>
+                            </div>
+                            """, unsafe_allow_html=True)
+                    else:
+                        st.info("暂无挑战记录")
+                except Exception as e:
+                    st.error(f"获取挑战记录失败: {str(e)}")
+
+# 页脚
+st.markdown("---")
+st.markdown("""
+<div style='text-align: center;'>
+    <p>Powered by Together AI, NocoDB, and Hugging Face Spaces</p>
+</div>
+""", unsafe_allow_html=True) 

config.py

@@ -0,0 +1,108 @@
+import os
+from dotenv import load_dotenv
+
+# 加载环境变量
+load_dotenv()
+
+# Together AI Configuration
+TOGETHER_API_KEY = os.getenv("TOGETHER_API_KEY")
+# 设置默认模型为 DeepSeek R1 Distill Llama 70B Free
+TOGETHER_MODEL = "deepseek-ai/deepseek-r1-distill-llama-70b-free"
+
+# NocoDB Configuration
+NOCODB_API_KEY = os.getenv("NOCODB_API_KEY")
+NOCODB_URL = os.getenv("NOCODB_URL")
+NOCODB_PROJECT_ID = os.getenv("NOCODB_PROJECT_ID")
+
+# Application Configuration
+APP_TITLE = "RPG Adventure Game"
+APP_DESCRIPTION = "An AI-powered RPG adventure game with character development, PVP battles, and Boss challenges"
+AVAILABLE_MODELS = [
+    "deepseek-ai/deepseek-r1-distill-llama-70b-free",
+    "meta-llama/Llama-3.3-70B-Instruct-Turbo-Free",
+    "mistralai/Mixtral-8x7B-Instruct-v0.1",
+    "meta-llama/Llama-3.3-70B-Instruct"
+]
+
+# Game Configuration
+GAME_CONFIG = {
+    "max_daily_points": 5,  # 每日最大属性点
+    "base_stats": {  # 基础属性
+        "ATK": 10,
+        "DEF": 10,
+        "MAG": 10,
+        "DEX": 10,
+        "LUK": 10
+    },
+    "classes": [  # 可用职业
+        "Warrior",
+        "Mage",
+        "Rogue",
+        "Priest",
+        "Archer"
+    ],
+    "class_base_stats": {  # 各职业初始属性
+        "Warrior": {
+            "ATK": 15,  # 高攻击力
+            "DEF": 15,  # 高防御力
+            "MAG": 5,   # 低魔法力
+            "DEX": 8,   # 中等敏捷
+            "LUK": 7    # 中等幸运
+        },
+        "Mage": {
+            "ATK": 5,   # 低攻击力
+            "DEF": 7,   # 低防御力
+            "MAG": 20,  # 高魔法力
+            "DEX": 8,   # 中等敏捷
+            "LUK": 10   # 较高幸运
+        },
+        "Rogue": {
+            "ATK": 12,  # 较高攻击力
+            "DEF": 7,   # 低防御力
+            "MAG": 8,   # 中等魔法力
+            "DEX": 18,  # 高敏捷
+            "LUK": 15   # 高幸运
+        },
+        "Priest": {
+            "ATK": 6,   # 低攻击力
+            "DEF": 12,  # 较高防御力
+            "MAG": 15,  # 高魔法力
+            "DEX": 8,   # 中等敏捷
+            "LUK": 9    # 中等幸运
+        },
+        "Archer": {
+            "ATK": 12,  # 较高攻击力
+            "DEF": 8,   # 中等防御力
+            "MAG": 7,   # 低魔法力
+            "DEX": 15,  # 高敏捷
+            "LUK": 8    # 中等幸运
+        }
+    },
+    "bosses": [  # 预设Boss
+        {
+            "id": 1,
+            "name": "Shadow Lord",
+            "ATK": 100,
+            "DEF": 80,
+            "MAG": 120,
+            "DEX": 60,
+            "LUK": 40
+        }
+    ]
+}
+
+def validate_config():
+    """Validate required environment variables"""
+    required_vars = {
+        "TOGETHER_API_KEY": TOGETHER_API_KEY,
+        "NOCODB_API_KEY": NOCODB_API_KEY,
+        "NOCODB_URL": NOCODB_URL,
+        "NOCODB_PROJECT_ID": NOCODB_PROJECT_ID
+    }
+    
+    missing_vars = [var for var, value in required_vars.items() if not value]
+    
+    if missing_vars:
+        raise ValueError(f"Missing required environment variables: {', '.join(missing_vars)}")
+
+validate_config() 

database/nocodb.py

@@ -0,0 +1,133 @@
+import requests
+from typing import Dict, List, Any, Optional
+from config import NOCODB_API_KEY, NOCODB_URL, NOCODB_PROJECT_ID
+from datetime import datetime
+import time
+import json
+
+class NocoDBClient:
+    def __init__(self):
+        self.base_url = NOCODB_URL.rstrip('/')
+        self.headers = {
+            "xc-token": NOCODB_API_KEY,
+            "Content-Type": "application/json"
+        }
+        self.project_id = NOCODB_PROJECT_ID
+        self.cache = {}
+        self.cache_timeout = 300  # Cache timeout in seconds
+        print(f"Initializing NocoDB client:")
+        print(f"Base URL: {self.base_url}")
+        print(f"Project ID: {self.project_id}")
+        print(f"Headers: {self.headers}")
+
+    def _get_cache_key(self, table_name: str, params: Optional[Dict[str, Any]] = None) -> str:
+        """Generate cache key"""
+        if params:
+            params_str = json.dumps(params, sort_keys=True)
+            return f"{table_name}:{params_str}"
+        return table_name
+
+    def _is_cache_valid(self, cache_key: str) -> bool:
+        """Check if cache is valid"""
+        if cache_key in self.cache:
+            cache_time, _ = self.cache[cache_key]
+            return time.time() - cache_time < self.cache_timeout
+        return False
+
+    def _get_cached_data(self, cache_key: str) -> Optional[List[Dict[str, Any]]]:
+        """Get cached data"""
+        if self._is_cache_valid(cache_key):
+            return self.cache[cache_key][1]
+        return None
+
+    def _set_cache_data(self, cache_key: str, data: List[Dict[str, Any]]) -> None:
+        """Set cache data"""
+        self.cache[cache_key] = (time.time(), data)
+
+    def _get_endpoint(self, table_name: str) -> str:
+        """Build API endpoint URL"""
+        return f"{self.base_url}/api/v1/db/data/v1/{self.project_id}/{table_name}"
+
+    def create_record(self, table_name: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Create new record"""
+        data['created_time'] = datetime.now().isoformat()
+        endpoint = self._get_endpoint(table_name)
+        try:
+            response = requests.post(endpoint, json=data, headers=self.headers)
+            response.raise_for_status()
+            self.cache.clear()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            print(f"Failed to create record: {str(e)}")
+            if hasattr(e.response, 'text'):
+                print(f"Error response: {e.response.text}")
+            raise
+
+    def get_records(self, table_name: str, params: Optional[Dict[str, Any]] = None) -> List[Dict[str, Any]]:
+        """Get records with caching"""
+        cache_key = self._get_cache_key(table_name, params)
+        cached_data = self._get_cached_data(cache_key)
+        if cached_data is not None:
+            return cached_data
+
+        endpoint = self._get_endpoint(table_name)
+        default_params = {
+            "limit": "25",
+            "offset": "0"
+        }
+        
+        if params and "where" in params:
+            where_condition = params["where"]
+            if where_condition.startswith("(") and where_condition.endswith(")"):
+                where_condition = where_condition[1:-1]
+                parts = where_condition.split(",")
+                if len(parts) == 3:
+                    field, op, value = parts
+                    if "-" in value or not value.isalnum():
+                        value = f"'{value}'"
+                    params["where"] = f"({field},{op},{value})"
+        
+        if params:
+            default_params.update(params)
+            
+        try:
+            response = requests.get(endpoint, params=default_params, headers=self.headers)
+            response.raise_for_status()
+            data = response.json().get("list", [])
+            self._set_cache_data(cache_key, data)
+            return data
+        except requests.exceptions.RequestException as e:
+            print(f"Failed to get records: {str(e)}")
+            if hasattr(e.response, 'text'):
+                print(f"Error response: {e.response.text}")
+            raise
+
+    def update_record(self, table_name: str, record_id: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Update record"""
+        endpoint = f"{self._get_endpoint(table_name)}/{record_id}"
+        try:
+            response = requests.patch(endpoint, json=data, headers=self.headers)
+            response.raise_for_status()
+            self.cache.clear()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            print(f"Failed to update record: {str(e)}")
+            if hasattr(e.response, 'text'):
+                print(f"Error response: {e.response.text}")
+            raise
+
+    def delete_record(self, table_name: str, record_id: int) -> None:
+        """Delete record"""
+        endpoint = f"{self._get_endpoint(table_name)}/{record_id}"
+        try:
+            response = requests.delete(endpoint, headers=self.headers)
+            response.raise_for_status()
+            self.cache.clear()
+        except requests.exceptions.RequestException as e:
+            print(f"Failed to delete record: {str(e)}")
+            if hasattr(e.response, 'text'):
+                print(f"Error response: {e.response.text}")
+            raise
+
+# 创建默认的 NocoDB 客户端实例
+nocodb_client = NocoDBClient() 

llm/together.py

@@ -0,0 +1,123 @@
+import together
+from typing import Dict, Any, List, Optional
+from config import TOGETHER_API_KEY, TOGETHER_MODEL, AVAILABLE_MODELS
+
+class TogetherAIClient:
+    def __init__(self):
+        together.api_key = TOGETHER_API_KEY
+        self.model = TOGETHER_MODEL
+
+    def generate_battle_story(self, attacker: Dict[str, Any], defender: Dict[str, Any]) -> str:
+        """Generate battle story"""
+        prompt = f"""You are an RPG game battle story generator. Generate a battle story and record directly, without any thought process.
+
+Battle Information:
+Attacker: {attacker['name']} ({attacker['class']})
+- Attack: {attacker['ATK']}
+- Defense: {attacker['DEF']}
+- Magic: {attacker['MAG']}
+- Dexterity: {attacker['DEX']}
+- Luck: {attacker['LUK']}
+
+Defender: {defender['name']} ({defender['class']})
+- Attack: {defender['ATK']}
+- Defense: {defender['DEF']}
+- Magic: {defender['MAG']}
+- Dexterity: {defender['DEX']}
+- Luck: {defender['LUK']}
+
+Output format:
+Battle Process: [Describe 1-2 key rounds of battle]
+Battle Result: [Clearly state who won]
+
+Requirements:
+1. Only output detailed and epic battle process and result
+2. Keep total length under 200 words
+3. Use precise language
+4. No thought process or analysis"""
+
+        return self.generate_response(prompt, max_tokens=500, temperature=0.7)
+
+    def generate_boss_story(self, team: List[Dict[str, Any]], boss: Dict[str, Any]) -> str:
+        """Generate Boss battle story"""
+        team_info = "\n".join([
+            f"- {member['name']} ({member['class']}): ATK {member['ATK']}, DEF {member['DEF']}, MAG {member['MAG']}, DEX {member['DEX']}, LUK {member['LUK']}"
+            for member in team
+        ])
+
+        prompt = f"""You are an RPG game Boss battle record generator. Generate a battle record directly, without any thought process.
+
+Battle Information:
+Team Members:
+{team_info}
+
+Boss: {boss['name']}
+- Attack: {boss['ATK']}
+- Defense: {boss['DEF']}
+- Magic: {boss['MAG']}
+- Dexterity: {boss['DEX']}
+- Luck: {boss['LUK']}
+
+Output format:
+Battle Process: [Describe 1-2 key rounds of battle]
+Battle Result: [Clearly state if Boss was defeated]
+
+Requirements:
+1. Only output battle process and result
+2. Keep total length under 150 words
+3. Use concise language
+4. No thought process or analysis"""
+
+        return self.generate_response(prompt, max_tokens=800, temperature=0.7)
+
+    def generate_response(
+        self,
+        prompt: str,
+        max_tokens: int = 1024,
+        temperature: float = 0.7,
+        top_p: float = 0.7,
+        top_k: int = 50,
+        repetition_penalty: float = 1.1,
+        stop: Optional[List[str]] = None
+    ) -> str:
+        try:
+            params = {
+                "model": self.model,
+                "prompt": prompt,
+                "max_tokens": max_tokens,
+                "temperature": temperature,
+                "top_p": top_p,
+                "top_k": top_k,
+                "repetition_penalty": repetition_penalty,
+            }
+            if stop:
+                params["stop"] = stop
+
+            response = together.Complete.create(**params)
+            if isinstance(response, dict) and 'output' in response:
+                return response['output']['choices'][0]['text']
+            elif isinstance(response, dict) and 'choices' in response:
+                return response['choices'][0]['text']
+            else:
+                raise Exception(f"Unexpected response format: {response}")
+                
+        except Exception as e:
+            raise Exception(f"Together AI API call failed: {str(e)}")
+
+    def get_available_models(self) -> List[Dict[str, Any]]:
+        """Get available models list"""
+        try:
+            return [{"name": model} for model in AVAILABLE_MODELS]
+        except Exception as e:
+            print(f"Failed to get models list: {str(e)}")
+            return [{"name": TOGETHER_MODEL}]
+
+    def set_model(self, model_name: str) -> None:
+        """Set model to use"""
+        if model_name in AVAILABLE_MODELS:
+            self.model = model_name
+        else:
+            print(f"Warning: Model {model_name} not in available list, using default model")
+            self.model = TOGETHER_MODEL
+
+together_client = TogetherAIClient() 

requirements.txt

@@ -0,0 +1,6 @@
+streamlit>=1.24.0
+plotly>=5.13.0
+pandas>=1.5.0
+python-dotenv>=0.19.0
+requests>=2.28.0
+together>=0.1.5