export const en = {
  translation: {
    title: 'Memory Bear.AI ',
    memoryBear: 'Memory Bear.AI',
    index:{
      viewGuide: 'View Guide',
      watchVideo: 'Watch Video',
      viewDetails: 'View Details',
      changeLog: 'Changelog',
      latestUpdate: 'Latest Update',
      appCount: 'Number of Spaces',
      userCount: 'Number of Users',
      latestUpdateDesc: 'Version v0.2.0 release: Added visual workflow editor, model performance monitoring panel, and multi tenant permission management system.',
      getStarted: 'Getting Started',
      startedDesc: 'Understand the core functions of the platform and quickly get started through graphic guidance and video tutorials. Includes a full process demonstration from creating a space to publishing an application.',
      spaceTitle:'Memory Bear Intelligent Space Management Platform',
      spaceSubTitle: 'Making it easier to implement intelligent models - a one-stop platform for model management, knowledge building, workflow orchestration, and spatial operations',
    },
    version:{
      releaseDate: 'Release Date',
      version: 'Version',
      name: 'Code Name'
    },
    quickActions:{
      title: 'Quick Actions',
      spaceManagement: 'Space Management',
      modelManagement: 'Model Management',
      workflowOrchestration: 'Workflow Orchestration',
      userManagement: 'User Management',
      dataExport: 'Data Export',
      logQuery:'Log Query',
      notificationReminder: 'Notification Reminder',
      helpCenter: 'Help Center',
      knowledgeBase: 'Knowledge Base',
      knowledgeBaseDesc: 'Manage and maintain your knowledge base data',
      modelManagementDesc: 'Configure and optimize AI model parameters',
      userManagementDesc: 'Manage system users and permission settings',
      systemSettings: 'System Settings',
      systemSettingsDesc: 'Configure global system parameters and options',
      memoryManagement: 'Memory Management',
      memoryManagementDesc: 'Manage user memories and conversation history',
      apiManagement: 'API Management',
      apiManagementDesc: 'Manage API keys and interface configurations',
      workflowEngine: 'Workflow Engine',
      workflowEngineDesc: 'Design and manage automated workflows',
      performanceMonitor: 'Performance Monitor',
      performanceMonitorDesc: 'Monitor system performance and operational status',
    },
    guide: {
      quickStart: 'Quick Start',
      createKnowledge: 'Create Knowledge Base',
      createKnowledgeDesc: 'Build your exclusive knowledge base to help AI better understand your business',
      manageModel: 'Manage Models',
      manageModelDesc: 'Configure and manage your AI models to optimize performance',
      createSpace: 'Create Space',
      createSpaceDesc: 'Create new workspaces to organize your projects and teams',
      systemConfig: 'System Configuration',
      systemConfigDesc: 'Configure system parameters to personalize your experience',
      startCreate: 'Start Creating',
      goManage: 'Go Manage',
      createNow: 'Create Now',
      goConfig: 'Go Configure',
    },
    indexTour:{
      startTitle:'Welcome to Memory Bear 👋',
      startDescription:'Not sure where to start? Head to Model Management first to get your models ready — everything else builds on that.👉 Click Model Management in the left menu to get started.',
      stepOne: 'This is Model Management',
      stepOneDescription: 'Here you can view and configure available models to get ready for building applications.Once your models are set, head to Space Management to create a space and continue.👉 Click Space Management in the left menu to move on.',
      stepTwo: 'This is Space Management',
      stepTwoDescription: 'Here you can create and manage spaces to organize models and data for different use cases.Once your spaces are ready, head to User Management to invite members and manage access.👉 Click User Management in the left menu to continue.',
      stepThree: 'This is User Management',
      stepThreeDescription: 'Here you can create users, assign roles, and manage access for your team.Once users are set up, the basic configuration is complete and you’re ready to start using the platform 🎉',
      finishButtonText: 'Get Started',
    },
    menu: {
      home: 'Home',
      tenantManagement: 'Tenant Management',
      socialPlatformIntegration: 'Social Platform Integration',
      privateMessage: 'Private Message',
      userManagement: 'User Management',
      roleManagement: 'Role Management',
      systemManage: 'System Manage',
      applicationManagement: 'Application',
      productManagement: 'Product Management',
      knowledgeManagement: 'KnowledgeBase ',
      knowledgeBase: 'Datasets Management',
      modelManagement: 'Model Management',
      memoryStore: 'Memory Store',
      apiParameters: 'API Parameters',
      userMemory: 'Memory Store',
      memberManagement: 'Member Management',
      memorySummary: 'Memory Summary',
      memoryConversation: 'Memory Validation',
      helpCenter: 'Help Center',
      memorySummaryHandlers: 'Memory Summary Handlers',
      createMemorySummary: 'Create Memory Summary',
      memoryManagement: 'Memory Management',
      spaceManagement: 'Space Management',
      memoryExtractionEngine: 'Memory Extraction Engine',
      forgettingEngine: 'Forgetting Engine',
      knowledgePrivate: 'Private',
      knowledgeShare: 'Share',
      knowledgeCreateDataset: 'Create Dataset',
      knowledgeDocumentDetails: 'Document Details',
      userMemoryDetail: 'UserMemory Detail',
      apiKeyManagement: 'API Key Management',
      toolManagement: 'Tool Management',
      emotionEngine: 'Emotion Engine',
      statementDetail: 'Emotion Memory',
      selfReflectionEngine: 'Self Reflection Engine',
      pricing: 'Pricing Management',
      orderPayment: 'Order Payment',
      orderHistory: 'Order History',
      spaceConfig: 'Space Configuration',
      ontology: 'Ontology Engineering',
      prompt: 'Prompt Engineering',
      skills: 'Skill Library',
    },
    dashboard: {
      total_models: 'Available Models',
      total_spaces: 'Active Spaces',
      total_users: 'Users',
      total_running_apps: 'Application Runs',
      desc_models: 'Includes {{ account }} LLM and {{ nums }} embedding',
      desc_spaces: 'compared to last week',
      desc_users: 'New additions this week',
      desc_running_apps: "Today's success rate",
      totalMemoryCapacity: 'Total Stored Memories',
      userMemory: 'User Memory',
      knowledgeBaseCount: 'Knowledge Bases',
      apiCallCount: 'API Calls',
      comparedToYesterday: 'compared to yesterday',
      thisWeek: 'this week',
      thisDay: 'day on day',
      failureRate: 'Failure Rate',
      application: 'Applications',
      total_num: 'Total Memory Capacity',

      lastDays: 'last {{days}} days',
      lastHalfYear: 'last 6 months',
      lastYear: 'last year',

      enterpriseMemory: 'Enterprise Memory',
      activeSpace: 'Active Space',
      memoryQualityIndex: 'Memory quality index',
      memoryAccuracy: 'memory accuracy',
      recallSuccessRate: 'recall success rate',
      memoryRelevance: 'memory relevance',
      forgettingExecutionRate: 'Forgetting Execution Rate',

      memoryClassificationDistribution: 'Memory classification distribution',
      knowledgeBaseTypeDistribution: 'Distribution of Knowledge Base Types',
      memoryGrowthTrend: 'Memory Growth Trend',
      corporateMemory: 'Corporate Memory',
      recentMemoryActivities: 'Recent Memory Activities',
      apiCallTrend: 'API call trend',
      quickOperation: 'Quick Operation',
      popularMemoryTags: 'Popular Memory Tags',

      title: 'Real-time Monitoring of Your AI Memory Core and Agent Status',
      loading: 'Loading...',
      knowledgeBases: 'Total Knowledge Bases',
      memoryItems: 'Total Memory Items',
      activeAgents: 'Active Agents',
      apiCalls: 'API Calls',
      apiCallsUnit: '(monthly)',
      memoryTrend: 'Memory Growth Trend',
      activeAgentList: 'Active Agent List',
      engineStatus: 'Engine Status',
      recentKnowledgeBases: 'Recently Updated Knowledge Bases',
      strategy: 'Strategy',
      memoryEngine: 'Memory Retrieval Engine',
      retrievalEngine: 'Selection Engine',
      memoryCleanup: 'Memory Summary',
      status: {
        online: 'Online',
        offline: 'Offline',
        normal: 'Running Normally',
        error: 'Running Abnormally',
        slow: '(Slow)',
        planned: 'Planned',
        inProgress: 'In Progress',
        completed: 'Completed'
      },

      extractMemoryContent: 'Extract Memory Content',
      createNewMemorySummary: 'Create New Memory Entry',

      createNewApplication: 'Create New Application',
      createNewApplicationDesc: 'Build an app in just 3 minutes with zero-code drag-and-drop.',

      createNewKnowledge: 'Create New Knowledge',
      createNewKnowledgeDesc: 'Transform your data into a fully searchable, dedicated knowledge base in seconds.',

      memoryConversation: 'Memory Conversation',
      memoryConversationDesc: 'The more you use it, the better AI understands you.',
      helpCenter: 'Help Center',
      helpCenterDesc: 'One-stop support to answer your questions and get you started fast.',
      memorySummary: 'View Memory Summary',
      memorySummaryDesc: 'View Memory Summary Report',

      activityEmpty: 'There is currently no memory activity',
      tagEmpty: 'There are no tag records at the moment～',

      chunk_count: 'Data Chunk',
      chunk_count_desc: '{{count}} data chunks currently being processed',
      statements_count: 'Statements',
      statements_count_desc: '{{count}} knowledge statements',
      triplet_count: 'Entity Relation Extraction',
      triplet_count_desc: '{{entities_count}} entity nodes and {{relations_count}} relationships built',
      temporal_count: 'Time Extraction',
      temporal_count_desc: '{{count}} time series records',

      dialogue: 'Dialogue',
      chunk: 'Chunk',
      statement: 'Statement',
      entity: 'Entity'
    },
    table: {
      totalRecords: 'Total {{total}} Articles'
    },
    header: {
      userInfo: 'User Info',
      logout: 'Logout',
      settings: 'Settings',
      profile: 'Profile',
      changePassword: 'Change Password',
      changePasswordDesc: 'Regularly changing passwords to protect account security',
      currentUser: 'Current User: {{username}}',
      language: 'Language',
      timeZone: 'Time Zone',
      zh: 'Chinese',
      en: 'English',
      setting: 'Setting',
      securitySettings: 'Security Settings',
      basicInfo: 'Basic Information'
    },
    language: {
      en: 'English',
      zh: 'Chinese'
    },
    user: {
      searchPlaceholder: 'search user…',
      userId: 'User ID',
      username: 'Username',
      subUsername: 'or Login account',
      usernameOrAccount: 'Username / Login Account',
      displayName: 'Display Name',
      role: 'Role',
      password: 'Password',
      status: 'Status',
      createTime: 'Creation Time',
      lastLoginTime: 'Last Login Time',
      createUser: 'Create User',
      resetPassword: 'Reset Password',
      resetPasswordSuccess: 'Password reset successful',
      resetPasswordFailed: 'Password reset failed',
      enabled: 'Enabled',
      enabledOpera: 'Activate',
      enabledConfirm: 'Are you sure to enable this user?',
      enabledConfirmSuccess: 'Enabled successfully',
      enabledConfirmFailed: 'Enabled failed',
      disabled: 'Disabled',
      disabledOpera: 'Deactivate',
      disabledConfirm: 'Are you sure to disable this user?',
      disabledConfirmSuccess: 'Disabled successfully',
      disabledConfirmFailed: 'Disabled failed',
      resetPasswordConfirm: 'Are you sure to reset the password for this user?',
      initialPassword: 'Initial password',
      superuser: 'Admin',
      normalUser: 'Normal User',
      newPassword: 'New Password',
      newPasswordPlaceholder: 'Automatically generated without input',
      autoGenerate: 'Auto Generate',
      email: 'Email',
      createdAt: 'Creation Time',
      member: 'Member',
      passwordRule: 'password should have at least 6 characters',
      authVerify: 'Identity Verification',
      authVerifyDesc: 'For security reasons, please verify your login password first',
      verify: 'Verify',
      loginPassword: 'Login Password',
      loginPasswordPlaceholder: 'Please enter the login password for the current account',
      loginPasswordVerifyFailed: 'Incorrect password, please try again',
      bindNewEmail: 'Bind New Email',
      sureChange: 'Confirm Change',
      sendEmailCode: 'Send Verification Code',
      currentEmail: 'Current Email',
      newEmail: 'New Email Address',
      emailCode: 'Verification Code',
      emailCodePlaceholder: 'Please enter the verification code received by the new email',
      sureChangeEmail: 'Confirm to change the bound email to',
      sureChangeEmailDesc: '?',
      changeSuccess: 'Changed successfully',
      sendSuccess: 'Verification code has been sent, please check',
      newEmailSameAsOld: 'New email cannot be the same as current email',
      emailCodeLengthRule: 'Please enter a 6-digit verification code',
      emailFormatError: 'Incorrect email format',
      sendCodeTooFrequent: 'Please resend after {{seconds}}s',
      retrySend: 'Can resend after {{seconds}}s',
    },
    timezones: {
      'Asia/Shanghai': 'China Standard Time (UTC+8)',
      'Asia/Kolkata': 'India Standard Time (UTC+5:30)',
      'Europe/Moscow': 'Moscow Standard Time (UTC+3)',
      'Europe/Berlin': 'Central European Time (UTC+1)',
      'Europe/London': 'Greenwich Mean Time (UTC+0)',
      'America/New_York': 'US Eastern Time Standard Time (UTC-5)',
      'America/Los_Angeles': 'US Pacific Standard Time (UTC-8)',

      'Asia/Tokyo': 'Japan Standard Time (UTC+9)',
      'Asia/Singapore': 'Singapore Standard Time (UTC+8)',
      'Asia/Hong_Kong': 'Hong Kong Standard Time (UTC+8)',
      'Asia/Taipei': 'Taipei Standard Time (UTC+8)',
      'Asia/Seoul': 'Korea Standard Time (UTC+9)',
      'Asia/Bangkok': 'Bangkok Time (UTC+7)',
      'Asia/Jakarta': 'Jakarta Time (UTC+7)',
      'Asia/Manila': 'Manila Time (UTC+8)',
      'Asia/Dubai': 'Dubai Time (UTC+4)',
      'Asia/Tashkent': 'Tashkent Time (UTC+5)',
      'Asia/Riyadh': 'Riyadh Time (UTC+3)',
      'Asia/Baku': 'Baku Time (UTC+4)',
      'Asia/Istanbul': 'Istanbul Time (UTC+3)',
      'Europe/Paris': 'Central European Time (UTC+1)',
      'Europe/Rome': 'Central European Time (UTC+1)',
      'Europe/Madrid': 'Central European Time (UTC+1)',
      'Europe/Amsterdam': 'Central European Time (UTC+1)',
      'Europe/Vienna': 'Central European Time (UTC+1)',
      'Europe/Stockholm': 'Central European Time (UTC+1)',
      'Europe/Oslo': 'Central European Time (UTC+1)',
      'Europe/Copenhagen': 'Central European Time (UTC+1)',
      'Europe/Zurich': 'Central European Time (UTC+1)',
      'Europe/Athens': 'Eastern European Time (UTC+2)',
      'Europe/Warsaw': 'Central European Time (UTC+1)',
      'Europe/Prague': 'Central European Time (UTC+1)',
      'Europe/Budapest': 'Central European Time (UTC+1)',
      'Europe/Belgrade': 'Central European Time (UTC+1)',
      'America/Chicago': 'Central Standard Time (UTC-6)',
      'America/Denver': 'Mountain Standard Time (UTC-7)',
      'America/Toronto': 'Eastern Standard Time (UTC-5)',
      'America/Vancouver': 'Pacific Standard Time (UTC-8)',
      'America/Mexico_City': 'Mexico City Time (UTC-6)',
      'America/Sao_Paulo': 'Sao Paulo Time (UTC-3)',
      'America/Buenos_Aires': 'Buenos Aires Time (UTC-3)',
      'America/Santiago': 'Santiago Time (UTC-4)',
      'America/Lima': 'Lima Time (UTC-5)',
      'America/Bogota': 'Bogota Time (UTC-5)',
      'America/Caracas': 'Caracas Time (UTC-4)',
      'Australia/Sydney': 'Sydney Time (UTC+10)',
      'Australia/Melbourne': 'Melbourne Time (UTC+10)',
      'Australia/Brisbane': 'Brisbane Time (UTC+10)',
      'Australia/Perth': 'Perth Time (UTC+8)',
      'New_Zealand/Auckland': 'Auckland Time (UTC+12)',
      'Africa/Cairo': 'Cairo Time (UTC+2)',
      'Africa/Johannesburg': 'South Africa Standard Time (UTC+2)',
      'Africa/Lagos': 'Lagos Time (UTC+1)',
      'Africa/Casablanca': 'Casablanca Time (UTC+0)',
      'Africa/Nairobi': 'Nairobi Time (UTC+3)',
      'Africa/Addis_Ababa': 'Addis Ababa Time (UTC+3)',
      'UTC': 'Coordinated Universal Time (UTC+0)',
    },
    common: {
      search: 'Search',
      operation: 'Operation',
      create: 'Create',
      edit: 'Edit',
      change: 'Change',
      update: 'Update',
      delete: 'Delete',
      confirm: 'Confirm',
      cancel: 'Cancel',
      save: 'Save',
      next: 'Next step',
      exit: 'Exit',
      back: 'Back',
      previous: 'Previous step',
      batchEnable: 'Batch Enable',
      batchDisable: 'Batch Disable',
      batchDelete: 'Batch Delete',
      exportList: 'Export List',
      selectPlaceholder: 'Please select {{title}}',
      inputPlaceholder: 'Please enter {{title}}',
      enterPlaceholder: 'Enter {{title}}',
      saveSuccess: 'Save Success',
      saveFailure: 'Save Failure',
      pleaseSelect: 'Please select',
      pleaseEnter: 'Please enter',
      select: 'Please select',
      all: 'All',
      enter: 'Please Enter',
      dragUploadTip: 'Drag and drop the file here, or ',
      uploadClickTip: 'click to import',
      supportedFileTypes: 'Supported file types: {{types}} format files',
      uploading: 'Importing, please be patient…',
      selectFile: 'Select file',
      copy: 'Copy',
      copySuccess: 'Copy Success',
      viewDetails: 'View Details',
      enabled: 'Enabled',
      disabled: 'Disabled',
      updateWarning: 'Update Warning',
      deleteWarning: 'Delete Warning',
      deleteWarningContent: 'Are you sure you want to delete this {{content}}?',
      uploadFileTipMax: 'Please upload no more than {{max}} MB in total, and no more than {{maxCount}} files at a time',
      apply: 'Apply',
      add: 'Add',
      addOption: 'Add Option',
      viewDetail: 'View Detail',
      confirmRemoveFile: 'Are you sure you want to remove this file?',
      deleteSuccess: 'Delete successfully',
      deleteFailed: 'Delete Failure',
      foldUp: 'Collapse',
      expanded: 'Expand',
      clickUploadIcon: 'click on the upload icon',
      export: 'Export',
      active: 'Active',
      inactive: 'Inactive',
      warning: 'Warning',
      confirmDeleteDesc: 'Are you sure to delete 【{{name}}】?',
      confirmChangeStatusDesc: 'Are you sure to change the status of 【{{name}}】?',
      operationSuccess: 'Operation successful',
      pleaseUpload: 'Please upload',
      returnToSpace: 'Return to Space',
      createSuccess: 'Created successfully',
      updateSuccess: 'Updated successfully',
      enable: 'Enable',
      disable: 'Disable',
      loading: 'Loading...',
      noMoreData: 'No more data',
      operateSuccess: 'Operation successful',
      deleted: 'Deleted',
      loginExpired: 'Login expired, please login again',
      permissionDenied: 'Permission denied, please contact administrator',
      apiNotFound: 'API not found',
      tooManyRequests: 'Too many requests, please try again later',
      serviceUpgrading: 'Service upgrading, please try again later',
      serverError: 'Server error',
      unknownError: 'Unknown request error',
      loginApiCannotRefreshToken: 'Login API cannot refresh token',
      logoutApiCannotRefreshToken: 'Logout API cannot refresh token',
      publicApiCannotRefreshToken: 'Public API cannot refresh token',
      refreshTokenNotExist: 'Refresh token does not exist',
      reset: 'Reset',
      refresh: 'Refresh',
      return: 'Return',
      statusEnabled: 'Available',
      statusDisabled: 'Unavailable',
      remove: 'Remove',

      fileSizeTip: 'File size cannot exceed {{size}}MB',
      fileAcceptTip: 'Unsupported file type:',
      nextStep: 'Next Step',
      prevStep: 'Previous Step',
      exportSuccess: 'Export successful',
      recommend: 'Recommend',
      default: 'Default',
      logoTip: `Supported image formats: JPG, PNG \n Suggested size: square ratio \n Maximum size: ≤ 2MB`,
      imageSquareRequired: 'Please upload a square image',
      nameInvalid: 'Name cannot start or end with a space',
      notAllSpaces: 'Cannot be all spaces',
      view: 'View',
    },
    model: {
      searchPlaceholder: 'search model…',
      type: 'Type',
      provider: 'Provider',
      status: 'Status',
      created: 'Created',
      configureBtn: 'Run Configuration',
      name: 'Name',
      displayName: 'Display Name',
      nameRequired: 'Please enter model name',
      namePlaceholder: 'Enter model name',
      vectorDimensionRequired: 'Please enter vector dimension',
      vectorDimensionInvalid: 'Vector dimension must be a positive integer',
      vectorDimensionPlaceholder: 'Enter vector dimension size',
      batchSizeRequired: 'Please enter batch size',
      batchSizeInvalid: 'Batch size must be between 1 and 100',
      batchSizePlaceholder: 'Enter number of texts to process at once',
      truncateStrategyRequired: 'Please select truncate strategy',
      truncateStrategyPlaceholder: 'Select how to handle text exceeding max length',
      truncateFromEnd: 'Truncate from end',
      truncateFromStart: 'Truncate from start',
      noTruncation: 'No truncation',
      saveConfiguration: 'Save Configuration',
      updateSuccess: 'Model updated successfully',
      updateFailed: 'Failed to update model',
      createSuccess: 'Model created successfully',
      createFailed: 'Failed to create model',

      modelConfiguration: 'Model Configuration',
      createModel: 'Create Model',
      modelName: 'Model Name',

      basicConfig: 'Basic Config',
      basicParameters: 'Basic Parameters',
      vectorDimension: 'Vector Dimension',
      dimensionSize: 'Dimension size of embedding vectors',
      batchSize: 'Batch Size',
      numberOfTexts: 'Number of texts to process at once',
      truncateStrategy: 'Truncate Strategy',
      exceedingMaxLength: 'How to handle text exceeding max length',
      splitFromStart: 'Split From Start',
      splitFromEnd: 'Split From end',
      noSplit: 'No Split',
      temperature: 'Temperature',
      temperatureDesc: 'Higher values make output more random, lower values more deterministic',
      maxToken: 'Max Tokens',
      maxTokenDesc: 'Maximum number of tokens to generate',
      topP: 'Top P',

      advancedConfig: 'Advanced Config',
      advancedParameters: 'Advanced Parameters',
      normalization: 'Normalization',
      vectorNormalizationMethod: 'Vector normalization method',
      maxInputLength: 'Max Input Length',
      maximumAllowed: 'Maximum number of input tokens allowed',
      encodingFormat: 'Encoding Format',
      enablePooling: 'Enable Pooling',
      poolingStrategy: 'Pooling Strategy',

      frequencyPenalty: 'Frequency Penalty',
      frequencyPenaltyDesc: 'Reduces frequency of repeated words',
      presencePenalty: 'Presence Penalty',
      presencePenaltyDesc: 'Encourages model to talk about new topics',
      stopSequences: 'Stop Sequences',
      stopSequencesDesc: 'Stop generating when these characters are encountered, separate with commas',
      streamOutput: 'Stream Output',
      jsonMode: 'JSON Mode',

      apiConfigForm: 'API Configuration',
      apiKey: 'API Key',
      apiKeyPlaceholder: 'Entet API Key',
      apiEndpoint: 'API Endpoint',
      timeout: 'Timeout (seconds)',
      autoRetry: 'Auto Retry',
      retryCount: 'Retry Count',

      saveConfig: 'Save Config',
      apiKeyName: 'API Key Name',

      llm: 'LLM',
      chat: 'Chat',
      embedding: 'Embedding',
      rerank: 'Rerank',
      openai: "Openai",
      dashscope: "Dashscope",
      ollama: "Ollama",
      xinference: "Xinference",
      gpustack: "Gpustack",
      bedrock: "Bedrock",
    },
    modelNew: {
      group: 'Model Group',
      list: 'Model List',
      square: 'Model Plaza',
      createGroupModel: 'Create Model Group',
      groupSearchPlaceholder: 'Search model groups',
      listSearchPlaceholder: 'Search available models',
      squareSearchPlaceholder: 'Search platform models',
      status: 'Model Status',
      created_at: 'Created At',
      configureBtn: 'Click to Configure',
      showModel: 'Show Model',
      keyConfig: 'Configure KEY',

      modelConfiguration: 'Model Configuration',
      logo: 'Model LOGO',
      name: 'Model Name',
      type: 'Model Type',
      modelImplement: 'Model Implementation',
      addImplement: 'Add Implementation',
      noAuth: 'Unauthorized (Limited to 1 implementation)',
      implementConfig: 'Configure Model Implementation',
      provider: 'Model Provider',
      api_key_ids: 'Select Model',
      viewAll: 'More',
      modelCount: 'Total {{count}} models',
      modelList: 'Model List',
      added: ' Added',
      addSuccess: 'Added successfully',
      model_name: 'Model Name',
      tags: 'Tags',
      createCustomModel: 'Add Custom Model',
      edit: 'Edit',
      selectOneTip: 'Model API KEY not configured, please configure it in the model list first',
      load_balance_strategy: 'Concurrency Strategy',
      round_robin: 'Sequential Execution - Call each model in order',
      none: 'None',

      api_key: 'API KEY',
      api_base: 'API Base URL',
      description: 'Description',
      add: 'Add',
      item: 'item',
      apiKeyNum: ' API Keys',
      official: 'Official',
      deprecated: 'Deprecated',

      llm: 'LLM',
      chat: 'Chat',
      embedding: 'Embedding',
      rerank: 'Rerank',
      openai: "Openai",
      dashscope: "Dashscope",
      ollama: "Ollama",
      xinference: "Xinference",
      gpustack: "Gpustack",
      bedrock: "Bedrock",

      is_vision: 'Vision Support',
      is_omni: 'Omni Support',
      vision: 'Vision',
      audio: 'Audio',
      video: 'Video',
    },
    knowledgeBase: {
      home: 'Home',
      selectSpace: 'Please select space',
      preview: 'Preview',
      pleaseUploadFileFirst: 'Please upload file first',
      shareSuccess: 'Share successfully',
      stopShareSuccess: 'Sharing is off. Access denied. ',
      shareFailed: 'Share failed',
      allModels: 'All Models',
      knowledgeBaseInfo: 'Knowledge base information',
      documentInfo: 'Document Information',
      documentPreview:'Document Preview',
      type: 'Type',
      permission_id: 'Permission',
      status: 'Status',
      created_at: 'Created At',
      createA: 'Create a',
      created: 'Created',
      insert: 'Insert',
      time: 'Time',
      updated_at: 'Updated At',
      updated: 'Updated',
      last_at: 'Last Updated',
      private: 'Private',
      share: 'Share',
      syncNow: 'Sync Now',
      syncing: 'Syncing...',
      syncSuccess: 'Sync started successfully',
      syncCompleted: 'Sync completed, data loaded successfully',
      syncTimeout: 'Sync timeout (1 minute), please try again later or check the sync status',
      syncFailed: 'Sync failed',
      syncError: 'Unable to sync, knowledge base not found',
      yuqueAuthRequired: 'Please enter Yuque User ID and Token',
      yuqueAuthSuccess: 'Yuque authentication successful',
      feishuAuthRequired: 'Please enter Feishu App ID, App Secret and Folder Token',
      feishuAuthSuccess: 'Feishu authentication successful',
      authFailed: 'Authentication failed, please check your credentials',
      recallTest: 'Recall Test',
      testQuestion: 'Test Question',
      doc_num: 'Document Number',
      chunk_num: 'Total data Size',
      adjustmentParameter:'Adjustment parameter',
      testQuestionPlaceholder: 'Please enter the question you want to test, for example, what are the main functions of the product…',
      loadSampleQuestions: 'Load sample questions',
      recallTestUnStart: 'Start testing knowledge base recall',
      recallTestUnStartSubTitle: 'Input the test question above and click the "Start Test" button to view the recall results',
      recallQuantity: 'Recall Quantity (Top K)',
      recallTestDescription:'Input test questions to evaluate the recall effectiveness and relevance of the knowledge base',
      similarityThreshold: 'Similarity Threshold',
      startTesting: 'Start Testing',
      semanticSimilarity: 'Semantic Similarity',
      recallResult: 'Result',
      setting: 'Setting',
      similarity: 'Similarity',
      searchPlaceholder: 'Search my knowledge base',
      description: 'Description',
      noDescription: 'This knowledge base has no description yet~',
      models: 'Model',
      owner: 'Owner',
      openKnowledgeBase: 'Open Knowledge Base',
      name: 'Name',
      myKnowledgeBase: 'My Knowledge Base',
      createKnowledgeBase: 'Create',
      generalKnowledgeBase: 'General Knowledge Base',
      knowledgeBase: 'Knowledge Base',
      selectDataSource: 'Select Source',
      localFile: 'Local File',
      uploadFileTypes: 'Upload PDF, TXT, DOCX, IMAGE, MEDIA and other format files',
      webLink: 'Web Link',
      webLinkPlaceholder:'Please enter',
      webLinkDesc: 'Only static links are supported. If the uploaded data shows as empty, the link may not be readable. One per line, with a maximum of {{count}} links at a time',
      selectorTutorial: 'Selector Usage Tutorial',
      readStaticWebPage: 'Read static web page content as dataset',
      customText: 'Custom Text',
      customContent: 'Custom Content',
      createContentError: 'Failed to create custom content',
      createLinkError: 'Failed to create link content',
      manuallyInputText: 'Manually input a text as dataset',
      importTemplate: 'Template Import',
      importBackup: 'Backup Import',
      downloadCSVTemplate: 'Click to download CSV template',
      downloadOriginal:'Download the original content',
      uploadCSVFile: 'Click or drag files here to upload',
      csvFileOnly: 'Only supports .csv files strictly following the template',
      fileLimit: 'Maximum 1 file, single file maximum 100MB',
      usageInstructions: 'Usage Instructions',
      importFromBackup: 'You can re-import the csv file downloaded when exporting the knowledge base.',
      csvTypeOnly: 'Supports .csv type files',
      fileLimit100MB: 'Maximum 1 file, single file maximum 100 MB',
      noDataSets: 'No datasets yet, click the button below or drag files to create.',
      createEmptyDataSet: '+ Empty Dataset',
      createImageDataSet: '+ Image Dataset',
      createContent: 'Create Content',
      title: 'Title',
      content: 'Content',
      pleaseEnterTitle: 'Please enter title',
      pleaseEnterContent: 'Please enter content',
      // createImageDataSet: '+ Image Dataset',
      dragFilesHere: 'Drag files here to upload',
      createImport: 'Create/Import',
      textDataSet: 'Text Dataset',
      imageDataSet: 'Image Dataset',
      mediaDataSet: 'Media Dataset',
      blankDataset: 'Blank Dataset',
      customTextDataset: 'Custom Text Dataset',
      text: 'Text',
      search: 'Search',
      image: 'Image',
      dataset: 'Dataset',
      emptyDataSet: 'Empty Dataset',
      view: 'View',
      edit: 'Edit',
      delete: 'Delete',
      rechunking: 'Rechunking',
      download: 'Download',
      selectSource:'Please select a source',
      confirmDelete: 'Are you sure you want to delete this document?',
      knowledgeBaseSettings: 'Knowledge Base Settings',
      modelConfiguration: 'Model Configuration',
      textUnderstandingModel: 'Text Understanding Model:',
      imageUnderstandingModel: 'Image Understanding Model:',
      scheduledSync: 'Scheduled Sync',
      cronExpression: 'Cron Expression:',
      testConnection: 'Test Connection',
      completed: 'Completed',
      pending: 'Pending',
      retrieve:'Retrieve',
      processing: 'Processing',
      processingMode: 'Processing Mode',
      processMsg: 'Processing Message',
      dataSize: 'Data Size',
      createUpdateTime: 'Create/Update Time',
      operation: 'Operation',
      datasets: 'General Knowledge Base',
      folder: 'Folder',
      general: 'General Knowledge Base',
      web: 'Web site synchronization',
      tp:'Third-party knowledge base integration',
      uploadFile: 'Upload File',
      selectFile: 'Select File',
      parameterSettings: 'Parameter Settings',
      dataPreview: 'Data Preview',
      confirmUpload: 'Confirm Upload',
      nextStep: 'Next Step',
      previousStep: 'Previous Step',
      clickOrDragFiles: 'Click or drag files here to upload',
      supportedFileTypes: 'Supports .txt, .docx, .csv, .xlsx, .pdf, .md, .html, .pptx type files',
      maxFileCount: 'Maximum 1000 files, single file maximum 500 MB',
      fileTooLarge: 'File size exceeds 500MB limit',
      fileLimitExceeded: 'File count exceeds 1000 limit',
      pleaseSelectFile: 'Please select file',
      dataProcessingSettings: 'Data Processing Settings',
      processingMethod: 'Processing Method',
      directBlock: 'Direct Chunking',
      qaExtract: 'QA Extraction',
      default: 'Default',
      customize: 'Customize',
      defaultSettings: 'Use system default parameters and rules',
      customSettings: 'Custom data processing rules',
      fileName: 'File Name',
      fileList: 'File List',
      blockPreview: 'Block Preview',
      processingDocuments: 'Processing documents, please wait...',
      chunkContent: 'Chunk Content',
      sampleChunk: 'Sample Chunk Content',
      noFilesSelected: 'No files',
      noChunksToPreview: 'No chunks to preview',
      clickToPreview: 'Click the file on the left to preview',
      maxPreviewChunks: 'Total {{count}} chunks, maximum {{max}} displayed',
      waiting: 'Waiting',
      startUpload: 'Total {{count}} files | Start Upload',
      startUploading: 'Start Uploading',
      startUploadConfirmTitle: 'Start Processing Documents',
      startUploadConfirmContent: 'Document processing will run in the background. You can choose to return to the list page immediately or stay on this page to view the processing progress.',
      returnToList: 'Return to List',
      stayOnPage: 'Stay on Page',
      uploadSuccess: 'Upload Success',
      datasetName: 'Dataset Name',
      pleaseEnterDatasetName: 'Please enter dataset name',
      uploadImages: 'Upload Images',
      uploadMedia: 'Upload Media files',
      pleaseUploadImages: 'Please upload images',
      embedding_id: 'Embedding',
      llm_id: 'LLM',
      image2text_id: 'Visual',
      chat_id: 'Chat',
      reranker_id: 'Reranker',
      deleteKnowledgeBase:'',
      progressComplete: 'Completed',
      progressing: 'Processing',
      toWorkspace: 'Authorization to workspace',
      shareTitle:'Please select the workspace you want to share',
      shareNote:'Note: Sharing is not possible when workspace app is closed',
      shareSpace:'Manage Sharing',
      shareSpaceTitle:'Shared with the following workspaces',
      shareSpaceNote: 'Note： sharing is turned off, others will no longer have access.',
      authorizedPerson:'Authorized person',
      chunkList:'Chunk List',
      delimiter:'Text paragraph delimiter',
      customDelimiterPlaceholder: 'Please enter the delimiter',
      suggestedBlockSize:'Suggested text block size',
      insertContent: 'Insert Content',
      editContent:'Edit Content',
      insertContentPlaceholder: 'Please enter the content',
      documentIdRequired: 'Document ID is required',
      editContentDesc:'Edit content',
      insertContentDesc:'Insert content',
      insertSuccess:'Insert successful',
      insertFailed:'Insert failed',
      updateSuccess: 'Update successful',
      updateFailed: 'Update failed',
      retrieveMode: 'Retrieve Mode',
      participle:'Participle',
      semantic:'Semantic',
      hybrid:'Hybrid',
      updateEmbeddingContent:'Are you sure about updating the embedding model? After the update, will the block vector data need to be reconstructed?',
      question: 'Question',
      answer: 'Answer',
      normalMode: 'Normal Mode',
      qaMode: 'QA Mode',
      fileParsingSettings: 'File Parsing Settings',
      pdfEnhancementAnalysis: 'PDF Enhancement Analysis',
      fileSizeExceeds: 'File size exceeds the limit',
      sizeLimitError: 'The file size exceeds the limit. The maximum supported size is 256MB. The current file size is',
      fileDurationExceeds: 'File duration exceeds the limit',
      fileDurationLimitError: 'The duration of the media file exceeds the limit. The maximum supported duration is 150 seconds. Current duration',
      unableReadFile:'Unable to read the information of the media file. Please check the file format.',
      // Knowledge Graph related
      graph: 'Graph',
      knowledgeGraph: 'Knowledge Graph',
      basicConfig: 'Basic Configuration',
      enableKnowledgeGraph: 'Enable Knowledge Graph',
      enableKnowledgeGraphTips: 'Once activated, it will automatically construct an entity relationship network.',
      graphConfig: 'Graph Configuration',
      sceneName: 'Scene Name',
      sceneNamePlaceholder: 'Please enter scene name',
      entityTypes: 'Entity Types',
      entityTypesPlaceholder: 'Please enter entity types, separate multiple types with line breaks',
      entityNormalization: 'Entity Normalization',
      entityNormalizationTips: 'Merge similar entities when enabled',
      entityMethod: 'Entity Method',
      entityMethodGeneral: 'General',
      entityMethodLight: 'Light',
      communityReportGeneration: 'Community Report Generation',
      communityReportGenerationTips: 'Generate community analysis reports when enabled',
      generateEntityTypes: 'Generate Entity Types',
      regenerateEntityTypes: 'Regenerate',
      generateEntityTypesSuccess: 'Entity types generated successfully',
      generateEntityTypesFailed: 'Failed to generate entity types',
      unknownError: 'Unknown error',
      pleaseSelectLLMModel: 'Please select a LLM model in basic configuration first',
      enterScenarioName: 'Please enter scenario name',
      entityDetails: 'Entity Details',
      entityDetailEmpty: 'Click on a node in the graph to view details',
      entityDetailEmptyDesc: 'Select an entity node to view its detailed information',
      entityDescription: 'Entity Description',
      graphTitle: 'Knowledge Graph: The Network of Entity, Relationship and Attribute Associations',
      graphTips: 'Explore the entity nodes in the knowledge base and their relationship networks',
      sourceDocuments: 'Source Documents',
      rebuildGraph: 'Rebuild Graph',
      rebuildConfirmTitle: 'Confirm the rebuild graph',
      rebuildConfirmContent: 'The rebuild graph will erase the existing map data and rebuild it from scratch. This operation is irreversible. Are you sure you want to proceed?',
      deleteGraphSuccess: 'Knowledge graph deletion successful',
      deleteGraphFailed:'Knowledge graph deletion failed',
      graphEmpty: 'At the foot of the mountain of books, the journey begins.',
      createForm:{
        name: 'Name',
        embedding_id: 'Embedding',
        description: 'Description',
        llm_id: 'LLM',
        image2text_id: 'Visual',
        chat_id: 'Chat',
        reranker_id: 'Rerank',
        permission_id: 'Permission',
        type: 'Type',
        status: 'Status',
        embeddingRequired: 'Please select an embedding model',
        nameRequired: 'Please enter a name',
        modelRequired: 'Please select a model',
        entryUrl: 'Entry URL',
        entryUrlRequired: 'Please enter entry URL',
        entryUrlInvalid: 'Please enter a valid URL',
        maxPages: 'Max Pages',
        maxPagesRequired: 'Please enter max pages',
        delaySeconds: 'Delay Seconds',
        delaySecondsRequired: 'Please enter delay seconds',
        timeoutSeconds: 'Timeout Seconds',
        timeoutSecondsRequired: 'Please enter timeout seconds',
        userAgent: 'User Agent',
        userAgentRequired: 'Please enter user agent',
        platform: 'Platform',
        platformRequired: 'Please select a platform',
        yuque: 'Yuque',
        feishu: 'Feishu',
        yuqueUserId: 'User ID',
        yuqueUserIdRequired: 'Please enter Yuque User ID',
        yuqueUserIdPlaceholder: 'Enter your Yuque User ID',
        yuqueToken: 'Token',
        yuqueTokenRequired: 'Please enter Yuque Token',
        yuqueTokenPlaceholder: 'Enter your Yuque Token',
        feishuAppId: 'Feishu Application ID',
        feishuAppIdRequired: 'Please enter Feishu Application ID',
        feishuAppIdPlaceholder: 'Enter your Feishu Application ID',
        feishuAppSecret: 'Feishu Application Secret',
        feishuAppSecretRequired: 'Please enter Feishu Application Secret',
        feishuAppSecretPlaceholder: 'Enter your Feishu Application Secret',
        feishuFolderToken: 'Folder Token',
        feishuFolderTokenRequired: 'Please enter Folder Token',
        feishuFolderTokenPlaceholder: 'Enter your Feishu Folder Token',
      }
    },
    api: {
      pageTitle: 'Memory library IAP document',
      pageSubTitle: 'This API provides interfaces for querying, analyzing, and exporting user memory data, assisting business parties in implementing functions such as personalized recommen-dations and user persona construction.',
      desc: 'Description',
      pathParams: 'Path parameter',
      parameterName: 'Parameter Name',
      type: 'Type',
      mandatory: 'Mandatory or not',
      input: 'Request Example',
      output: 'Response Example',
    },
    memory: {
      userMemoryPlaceholder: 'Search for user names, roles, or tags',
      totalNum: 'Total number of user',
      onlineNum: 'Online user count',
      todayKnowledgeNum: "Today's interactive knowledge entry",
      avgInteractionTime: "Average interaction duration",
      knowledgeEntryCount: 'Knowledge entry',
      interactionCount: 'Number of interactions',
      averageTimeConsumption: 'Average interaction duration',
      dataCompletionDegree: 'Data completion degree',
      knowledgeMasteryDegree: 'Knowledge mastery degree',
      learningEntries: 'Learning entries',
      conversationCount: 'Number of conversations',
      taskSuccessRate: 'Task success rate',
      memoryMap: 'Memory Map',

      createConfiguration: 'Create configuration',
      editConfiguration: 'Edit configuration',
      desc: 'Description',
      memoryExtractionEngine: 'Memory Extraction Engine',
      forgottenEngine: 'Forgotten Engine',
      active: 'Active',
      inactive: 'Inactive',
      configurationName: 'Configuration Name',
      emotionEngine: 'Emotion Engine',
      reflectionEngine: 'Self-Reflection Engine',
      scene_id: 'Ontology Scenario',
    },
    member: {
      username: 'Username',
      account: 'Account',
      role: 'Role',
      lastLoginTime: 'Last Login Time',
      editMember: 'Edit Member',
      createMember: 'Add Member',
      email: 'Email',
      inviteToMember: 'Member Role',
      member: 'Member',
      memberDesc: 'Can only use the application, cannot create the application',
      sendInvitation: 'Send Invitation',
      manager: 'Admin',
      managerDesc: 'Can access applications, but cannot create or manage them',
      inviteLinkDesc: 'Invite link 【{{inviteLink}}】, please copy and send to the member',
      inviteLinkTip: 'Please copy the invite link and send it to the user to complete the invitation',
    },
    memorySummary: {
      searchPlaceholder: 'Search for users, summary content, or tags',
      extractSettings: 'Extract Settings',
      time: 'Time',
      user: 'User',
      memorySummary: 'Memory Summary',
      tag: 'Tag',
      feedback: 'Feedback',
      extractAgentConfig: 'Extract Stage Agent Config',
      extractAgentConfigDesc: 'Here is the configuration for the Agent that extracts and preprocesses raw data from the source.',
      node: 'Node',
      agentName: 'Agent Name',
      coreResponsibilities: 'Core Responsibilities',
      input: 'Input',
      output: 'Output',
    },
    forgettingEngine: {
      forgettingEngine: 'Forgetting Engine',
      memoryOverview: 'Memory Overview',
      forgettingCurve: 'Forgetting Curve',
      memoryID: 'Memory ID',
      contentSummary: 'Content Summary',
      type: 'Type',
      createTime: 'Create Time',
      lastCallTime: 'Last Call Time',
      retentionDegree: 'Retention Degree (R)',
      status: 'Status',
      strategyImpactSimulator: 'Strategy Impact Simulator',
      abnormalCurveWarning: 'Abnormal Curve Warning',
      curveDataList: 'Curve Data List',
      MinimumRetention: 'Minimum Retention',
      currentRetentionRate: 'Current Retention Rate',
      finallyActivated: 'Finally Activated',
      expectedForgettingTime: 'Expected Forgetting Time',
      reinforcementCount: 'Reinforcement Count',
      saveAsDraft: 'Save as Draft',
      restoreDefault: 'Restore Default',

      minimumRetention: 'Minimum retention (λ_time)',
      minimumRetentionDesc: 'Controls the minimum retention threshold of memory retention',
      forgettingRate: 'Forgetting rate (λ_mem)',
      forgettingRateDesc: 'Control the speed of memory forgetting, the higher the value, the faster the forgetting',
      offset: 'Offset (offset)',
      offsetDesc: 'The offset of the minimum preservation degree',
      CurrentValue: 'Current Value',
      range: 'Range',
      forgettingEngineConfigParams: 'Forgetting Engine Configuration Parameters',
      theoreticalForgettingCurve: 'Theoretical Forgetting Curve',
      quicklyForget: 'Quickly forget',
      slowForgetting: 'Slow forgetting',
      currentConfig: 'Current Config',

      decay_constant: 'Decay Constant',
      max_history_length: 'Max Access History Length',
      forgetting_threshold: 'Forgetting Threshold',
      min_days_since_access: 'Minimum Days Since Access',
      enable_llm_summary: 'Enable LLM Summary Generation',
      max_merge_batch_size: 'Max Merge Batch Size',
      forgetting_interval_hours: 'Forgetting Interval Hours'
    },
    application: {
      searchPlaceholder: 'Search for applications or clusters',
      createApplication: 'Create Application',
      type: 'Type',
      source: 'Source',
      created_at: 'Create Time',
      shared: 'Shared',
      configuration: 'Configuration',

      applicationName: 'Application Name',
      applicationIcon: 'Application Icon',
      applicationType: 'Application Type',

      agent: 'Agent',
      agentDesc: 'Create a single intelligent agent',
      multi_agent: 'Cluster',
      multi_agentDesc: 'Create an Agent Cluster',
      workflow: 'Workflow',
      workflowDesc: 'To be opened, please stay tuned',
      editApplication: 'Edit Application Info',


      currentModel: 'Current Model',
      modelConfig: 'Model Config',
      parameterConfig: 'Parameter Configuration',

      apply: 'Apply',
      resetDefault: 'Reset Default',

      AIPromptAssistant: 'AI Prompt Assistant',
      generatedPrompt: 'Generated Prompt',
      conversationOptimizationPrompt: 'Conversation Optimization Prompt',

      variable: 'Variable',
      variableType: 'Variable Type',
      variableKey: 'Variable Key',
      variableName: 'Variable Name',
      optional: 'Optional',
      defaultValue: 'Default Value',
      options: 'Options',
      editVariable: 'Edit Variable',

      text: 'Text',
      paragraph: 'Paragraph',
      dropdownOptions: 'Dropdown Options',
      number: 'Number',
      checkbox: 'Checkbox',
      apiVariable: 'API Variable',

      displayName: 'Display Name',
      maxLength: 'Max Length',
      required: 'Required',
      hidden: 'Hidden',
      invalidVariableName: 'Variable name can only start with English letters and contain English letters, numbers, and underscores',
      defaultChecked: 'Default Checked',
      notDefaultChecked: 'Not Default Checked',
      apiExtension: 'API Extension',
      addApiExtension: 'Add API Extension',
      name: 'Name',
      apiEndpoint: 'API Endpoint',
      apiKey: 'API-Key',
      returnToApplicationList: 'Return to application list',
      arrangement: 'Configuration',
      api: 'API',
      release: 'Release',
      promptConfiguration: 'Prompt Configuration',
      configurationDesc: 'Define the role, capabilities, and behavioral guidelines of the Agent',
      aiPrompt: 'AI Prompt',
      promptPlaceholder: 'You are a professional AI assistant, and your responsibility is to help users solve problems.',
      knowledgeBaseAssociation: 'Knowledge Base Association',
      associatedKnowledgeBase: 'Associated Knowledge Bases',
      addKnowledgeBase: 'Add Knowledge Base',
      knowledgeEmpty: 'No knowledge base associated.',
      memoryConfiguration: 'Memory Configuration',
      dialogueHistoricalMemory: 'Conversation History Memory',
      dialogueHistoricalMemoryDesc: 'Enable this to select memory content from memory management.',
      toolConfiguration: 'Tool Configuration',
      webSearch: 'Web Search',
      webSearchDesc: 'Allow the Agent to access the Internet for real-time search',
      codeExecutor: 'Code Executor',
      codeExecutorDesc: 'Allow Agent to execute Python code',
      imageGeneration: 'Image Generation',
      imageGenerationDesc: 'Enable AI image generation capability',
      variableConfiguration: 'Variable Configuration',
      selectMemoryContent: 'Select Memory Content',
      selectMemoryContentDesc: 'From Memory Management Select the memory content to be used in the conversation',
      VariableManagement: 'Variable Management',
      VariableManagementDesc: 'Configure the available variables for the Agent',
      addVariables: 'Add Variables',
      variablesEmpty: 'There are currently no variables available',
      debuggingEmpty: 'No models available for debugging.',
      debuggingEmptyDesc: 'Click the “+” button to select and add a model.',
      debuggingAndPreview: 'Preview and Debugging',
      addModel: 'Add Model',
      fieldName: 'Field Name',
      Optional: 'Optional',
      chatEmpty: 'Send a message to start testing',
      chatPlaceholder: 'Start a conversation...',

      endpointConfiguration: 'Endpoint Configuration',
      authenticationMethod: 'Authentication Method',
      apiKeyTitle: 'API KEY',
      apiKeyDesc: 'Simple and fast',
      refreshSecret: 'Refresh Secret',
      requestResponseExample: 'Request/Response Example',
      requestExample: 'Request Example (cURL)',
      downloadPostmanCollection: 'Download Postman Collection',
      responseExample: 'Response Example (JSON)',
      rateLimitingStrategy: 'Rate Limiting Strategy',
      qpsRestrictions: 'QPS Restrictions',
      dailyAdjustmentDosage: 'Daily Adjustment Dosage',
      tokenCap: 'Token Cap',
      sdkDownload: 'SDK Download',
      pythonSDK: 'Python SDK',
      nodejsSDK: 'Node.js SDK',
      goSDK: 'Go SDK',
      curlExample: 'CURL Example',
      advancedSettings: 'Advanced Settings',
      WebhookReturnsTimeout: 'Webhook Returns Timeout',
      WebhookReturnsTimeoutDesc: 'Platform hard limit, maximum 30 seconds',
      whitelistIP: 'Whitelist IP',
      whitelistIPDesc: 'supports CIDR',
      publicAPIDocumentation: 'Public API Documentation',

      versionList: 'Versions',
      versionListDesc: 'Release history and status',
      current: 'Current',
      rolledBack: 'rolled back',
      history: 'history',
      VersionInformation: 'Version Information',
      publishedOn: 'Published on',
      publisher: 'Published by',
      DetailsOfVersion: 'Version Details: {{version}}',
      exportDSLFile: 'Export DSL file',
      willRollToThisVersion: 'Will roll to this version',
      share: 'Share',
      lastUpdateTime: 'Last Update Time',
      editor: 'Editor',
      releaseTime: 'Release Time',
      changeLog: 'Changelog',
      fix: 'Fix',
      optimization: 'Optimization',
      new: 'New',
      update: 'Update',
      adjustment: 'Adjustment',
      basicInformation: 'Basic Information',
      clusterName: 'Cluster Name',
      clusterDescription: 'Cluster Description',
      clusterDescriptionPlaceholder: 'This is an Agent cluster specifically designed to handle core business, capable of collaborating to complete complex business processing tasks.',
      toolCalling: 'Tool Calling',
      toolCallingDesc: 'The main control agent calls sub agents as tools',
      toolCallingFeature: 'Centralized control, suitable for structured workflow',
      handoffsFeature: 'Decentralized control, suitable for complex conversation scenarios',
      recommend: 'Recommend',
      advanced: 'Advanced',
      multiAgentArchitecture: 'Multi Agent architecture pattern',
      supervisorAgent: 'Supervisor Agent',
      model: 'Model',
      responsibility: 'Responsibility',
      systemPrompt: 'System Prompt',
      subAgentsManagement: 'Sub Agents Management',
      added: 'Added',
      addSubAgent: 'Add Sub Agent',
      contextEngineering: 'Context Engineering',
      dialogueHistoryManagement: 'Dialogue History Management',
      stateSharingStrategy: 'State Sharing Strategy',
      intermediateResultProcessing: 'Intermediate Result Processing',
      metadataTransfer: 'Metadata Transfer',
      knowledgeConfig: 'Knowledge Base Configuration',
      temperature: 'Temperature',
      temperature_desc: 'Temperature parameters, control the randomness of output',
      max_tokens: 'Max Tokens',
      max_tokens_desc: 'Maximum number of generated tokens',
      top_p: 'Top P',
      top_p_desc: 'Kernel sampling parameters',
      frequency_penalty: 'Frequency Penalty',
      frequency_penalty_desc: 'Frequency penalty',
      presence_penalty: 'Presence Penalty',
      presence_penalty_desc: 'Presence Penalty',
      n: 'Number of Replies Generated (n)',
      n_desc: 'Number of replies generated',

      contains: 'Contains {{include_count}} documents',
      top_k: 'Top K',
      top_k_desc: 'Return the K most relevant document fragments',

      chooseModel: 'Choose Model',

      releaseNewVersion: 'Release New Version',
      versionNumber: 'Version Number',
      versionNumberTip: 'Version number format: v[major version number].[next version number].[revision number] (e.g. v1.3.0)',
      versionDescription: 'Version Description',
      versionDescriptionTip: 'Please describe the feature updates, bug fixes, and optimizations included in this release.',
      releasePreview: 'Release Preview',
      globalConfig: 'Global Config',
      globalConfigDesc: 'The global configuration will be applied to all associated knowledge bases as the default configuration. The configuration of a single knowledge base will override the global configuration.',
      rerankModel: 'Rerank Model',
      rerankModelDesc: 'After activation, the search results will be reordered to improve their relevance',
      rearrangementModel: 'Rearrangement Model',
      rearrangementModelDesc: 'Select the model for reordering',
      reranker_top_k: 'Top K',
      reranker_top_k_desc: 'The number of document fragments returned, ranging from 1 to 20',

      retrieve_type: 'Retrieve type',
      retrieve_type_desc: 'Choose the retrieval method for the knowledge base, different modes have different parameter configurations',

      participle: 'Participle retrieval',
      semantic: 'Semantic retrieval',
      hybrid: 'Hybrid Retrieval',

      similarity_threshold: 'Semantic similarity threshold',
      similarity_threshold_desc: 'Only return results with semantic similarity higher than this threshold',
      similarity_threshold_desc1: 'The minimum similarity threshold for semantic retrieval',

      vector_similarity_weight: 'Vector Similarity Weight',
      vector_similarity_weight_desc: 'Only return results with BM25 scores above this threshold',
      vector_similarity_weight_desc1: 'The minimum BM25 score threshold for word segmentation retrieval',

      description: 'Description',
      shareVersion: 'Share Version',
      shareLink: 'Share Link',
      shareLinkTip: 'Tip: The sharing link is valid for 7 days, and the recipient needs to have the corresponding permissions to access it.',

      copyApplication: 'Copy Application',
      chooseKnowledge: 'Choose Knowledge Base',
      active: 'Active',
      inactive: 'Inactive',
      versionName: 'Version Name',
      versionNameTip: 'Version number format: v[major version number].[next version number].[revision number] (e.g. v1.3.0)',
      agentName: 'Agent Name',
      roleType: 'Role Type',

      coordinator: 'Coordinator',
      analyzer: 'Analyzer',
      executor: 'Executor',
      reviewer: 'Reviewer',
      updateSubAgent: 'Update Sub Agent',
      subAgentMaxLength: 'Sub Agent maximum {{maxLength}}',
      capabilities: 'Capabilities',
      subAgent: 'Sub Agent',
      maxChatCount: 'Add up to 4 models',
      ReplyException: 'Reply exception',

      endpointConfigurationSubTitle: 'Configure API access address and supported HTTP methods',
      apiKeys: 'API Key Management',
      apiKeySubTitle: 'Manage API keys, view usage and traffic statistics for each key',
      addApiKey: 'Add New API Key',
      apiKeyName: 'Key Name',
      apiKeyNamePlaceholder: 'e.g.: Production, Testing, Development',
      apiKeyDescPlaceholder: 'Describe the purpose of this Key',
      apiKeyTotal: 'Total Keys',
      apiKeyRequestTotal: 'Total Requests',
      qps: 'Average QPS',
      qpsLimit: 'QPS Limit',
      qpsLimitTip: '(Requests per second)',
      apiLimitConfig: 'Rate Limiting Configuration',
      qpsLimitDesc: 'Limit the maximum number of requests this Key can make per second',
      dailyUsageLimit: 'Daily Usage Limit',
      dailyUsageLimitDesc: 'Limit the maximum total number of requests this Key can make per day',
      dailyUsageLimitUnit: 'times/day',
      apiKeyDeleteContent: 'Once deleted, it cannot be recovered, and applications using this Key will not be able to access the API',
      currentValue: 'Current Value',
      qpsLimitUnit: 'times/second',
      addVariable: 'Insert Variable',
      defineVariableName: 'Custom Variable Name',
      defineVariableNamePlaceholder: 'Enter variable name, e.g.: user_name',
      defineVariableNameExtra: 'Format: Variable name will be automatically wrapped with {{}}',
      you: 'You',
      ai: 'AI Assistant',
      promptChatPlaceholder: 'Describe the prompt you need, e.g.: I need a customer service assistant',
      promptChatEmpty: 'No conversation content available',
      promptEmpty: 'Describe your use case on the left, and the orchestration preview will be displayed here.',

      master: 'Supervisor Mode',
      supervisor: 'Supervisor Mode',
      supervisorDesc: 'Unified scheduling and management by the main Agent, with sub-Agents executing tasks assigned by the supervisor, suitable for scenarios requiring centralized control.',
      collaboration: 'Collaboration Mode',
      collaborationDesc: 'Multiple Agents collaborate equally, autonomously coordinating according to task requirements, suitable for complex scenarios requiring flexible interaction.',
      masterConfig: 'Supervisor Configuration',
      orchestrationMode: 'Task Assignment Strategy',
      conditional: 'Intelligent Assignment',
      sequential: 'Sequential Assignment',
      parallel: 'Parallel Assignment',
      aggregationStrategy: 'Result Aggregation Method',
      merge: 'Complete Aggregation',
      vote: 'Key Information Extraction',
      priority: 'Structured Integration',
      addTool: 'Add Tool',
      tool: 'Tool',
      variableConfig: 'Variable Configuration',

      statistics: 'Data Statistics',
      daily_conversations: 'Daily Conversations',
      daily_new_users: 'Daily New Users',
      daily_api_calls: 'Daily API Calls',
      daily_tokens: 'Token Consumption',

      skill: 'Skill Configuration',
      skillTitle: 'Configure Agent skills and matching modes',
      skillHelp: 'Help Center',
      addSkill: 'Add Skill',
      dynamicBindingSkill: 'Dynamic Optional Skills',
      dynamicBindingSkill_subTitle: 'Skill pool that Agent can automatically match based on tasks',
      dynamicBindingSkill_empty: 'No dynamic skills configured yet, click the button above to add or enable "Allow access to all skills"',
      chooseSkill: 'Choose Skill',
      allSkill: 'Allow access to all skills',
      allSkillIntro: 'Access to all skills enabled, Agent will automatically match optimal skills based on tasks',
      executeProcessPreview: 'Execution Process Preview',
      receiveTask: 'Receive Task',
      analyTask: 'Analyze Task Intent',
      dynamicMatchSkill: 'Dynamic Match Skill',
      executeTask: 'Execute Task',

      import: 'Import Application',
      importWorkflow: 'Third-Party Workflow',
      importThirdParty: 'Import Workflow',
      platform: 'Source Platform',
      upload: 'Upload & Parse',
      complex: 'Compatibility Analysis',
      sureInfo: 'Information Confirmation',
      completed: 'Import Completed',
      baseInfo: 'Basic Information',
      workflowName: 'Workflow Name',
      fileName: 'File Name',
      fileSize: 'File Size',
      importSuccess: 'Import Success',
      importSuccessDesc: 'Workflow imported successfully, you can view and manage it in the application management',
      gotoList: 'Return to Application List',
      gotoDetail: 'View Details',
      dify: 'Dify',
      pleaseUploadFile: 'Please upload file', 
      setting: 'Settings',
      funConfig: 'Features',
      fileUpload: 'File Upload',
      fileUploadDesc: 'The chat input box supports file uploads. Types include images, documents, and other types',
      settings: 'File Upload Settings',
      uploadType: 'Upload Type',
      local: 'Local Upload',
      both: 'Both',
      maxSize: 'Maximum Upload',
      maxSizeDesc: 'Documents < 200.00MB, Images < 10.00MB, Audio < 50.00MB, Video < 100.00MB',
      supportedTypes: 'Supported File Types',
      document: 'Document',
      image: 'Image',
      audio: 'Audio',
      video: 'Video',
      other: 'Other File Types',
      otherFormats: 'Specify other file types',
      maxCount: 'Max Files',
      singleMaxSize: 'Max Size',
      unix: 'items',
      textTranfer: 'Text to Speech',
      textTranferDesc: 'Text can be converted to speech',

      apps: 'My Apps',
      sharing: 'Sharing',
      sharingApp: 'Shared Apps',
      myShare: 'My Shares',
      selectTargetSpace: 'Select Target Space',
      alreadyShared: 'Already Shared',
      permissionMode: 'Permission Mode',
      readonlyMode: 'Use Shared',
      readonlyModeDesc: 'Can test and run, cannot view internals',
      editableMode: 'Copy Shared',
      editableModeDesc: 'Copy full replica, free to edit',
      confirmSharing: 'Confirm Sharing',
      selectAtLeastOneSpace: 'Please select at least one target space',
      test: 'Conversation Test',
      log: 'Logs',
      testChatEmpty: 'Send a message to test the shared app',
      allCancel: 'Cancel All',
      cancelShare: 'Cancel Sharing',
      confirmAppCancelShareDesc: 'Are you sure to cancel sharing of 【{{app}}】 app with 【{{workspace}}】 space? The other party will no longer have access after cancellation.',
      confirmWorkspaceCancelShareDesc: 'Are you sure to cancel all apps shared with 【{{workspace}}】? This action cannot be undone.',
      sourceActive: 'Active',
      sourceInactive: 'Inactive',
      readonly: 'Use Only',
      editable: 'Copyable',
      version: 'Version',
      permission: 'Permission',
      souceStatus: 'Source App Status',
      confirmCopyDesc: 'Are you sure to copy 【{{app}}】 app?',
      noShareAuth: 'No permission to share apps',
      appCount: '{{count}} apps shared to this space',
    },
    userMemory: {
      userMemory: 'User Memory',
      total_num: 'Total Number of Users',
      online_num: 'Number of Online Users',

      user: 'User',
      knowledgeEntryCount: 'Knowledge Entry Count',
      interactionCount: 'Interaction Count',
      averageTimeConsumption: 'Average Time Consumption',

      recentMemories: 'Recent Memories',
      memoryInsight: 'Memory Insight',
      relationshipNetwork: 'Relationship Network',
      aboutMe: 'About Me',
      foldUp: 'Collapse',
      interestDistribution: 'Interest Distribution',
      memoryDetails: 'Memory Details',
      importantMomentsInLife: 'Important Moments in Life',
      viewCompleteAnalysis: 'View Complete Analysis',
      click: 'Click on the node to view details',
      drag: 'Drag and drop to move nodes',
      zoom: 'Scroll zoom view',
      memoryDetailEmpty: 'Please select a memory node',
      memoryDetailEmptyDesc: 'Click a node in the graph to view memory details.',

      totalNumOfMemories: 'Total Number of Memories',
      footprintCity: 'Footprint City',
      totalNumOfPhotos: 'Total number of photos',
      importantRelationships: 'Important Relationships',

      currentResidence: 'Current residence',
      graduation: 'Graduation',
      emotions: 'Emotions',
      occupation: 'Occupation',
      memories: 'memories',
      expanded: 'Expand',
      description: 'Description',
      conversationMemory: 'Conversation Storage Content',
      editConfig: 'Edit Config',
      chooseModel: 'Choose Model',

      nodeStatistics: 'Memory Categories',
      total: 'Total',

      PERCEPTUAL_MEMORY: 'Perceptual Memory',
      WORKING_MEMORY: 'Working Memory',
      SHORT_TERM_MEMORY: 'Short-Term Memory',
      LONG_TERM_MEMORY: 'Long-Term Memory',
      EXPLICIT_MEMORY: 'Explicit Memory',
      IMPLICIT_MEMORY: 'Implicit Memory',
      EMOTIONAL_MEMORY: 'Emotional Memory',
      EPISODIC_MEMORY: 'Episodic Memory',
      FORGET_MEMORY: 'Forget Memory',

      endUserProfile: 'Profile',
      editEndUserProfile: 'Edit',
      other_name: 'Name',
      position: 'Position',
      department: 'Department',
      contact: 'Contact',
      phone: 'Phone',
      hire_date: 'Hire Date',
      memoryContent: 'Memory Content',
      created_at: 'Created At',
      updated_at: 'Last Updated',
      fullScreen: 'Full Screen',

      memoryWindow: "{{name}}'s Memory Overview",
      memory_insight: 'Overall Overview',
      key_findings: 'Key Findings',
      behavior_pattern: 'Behavior Pattern',
      growth_trajectory: 'Growth Trajectory',
      personality: 'Personality Traits',
      core_values: 'Core Values',

      Statement_emotion_keywords: 'Emotion Keywords',
      Statement_emotion_type: 'Emotion Type',
      Statement_emotion_subject: 'Emotion Subject',
      Statement_importance_score: 'Importance Score',

      ExtractedEntity_description: 'Description',
      ExtractedEntity_name: 'Content',
      ExtractedEntity_entity_type: 'Type',
      ExtractedEntity_created_at: 'Created At',
      ExtractedEntity_aliases: 'Aliases',
      ExtractedEntity_connect_strngth: 'Connection Strength',
      ExtractedEntity_importance_score: 'Importance Score',

      associative_memory: 'Associative Memory',
      unix: 'items',
      completeMemory: 'Complete Memory',
      relationshipEvolution: 'Relationship Evolution',
      timelineMemories: 'Long-term Memory',
      emotionLine: 'Emotion Changes Over Time',
      interaction: 'Interaction Frequency & Relationship Stages',
      timelines_memory: 'All',
      Chunk: 'Chunk',
      MemorySummary: 'Long-term Accumulation',
      Statement: 'Emotional Memory',
      ExtractedEntity: 'Episodic Memory',
      positive: 'Positive Emotion',
      negative: 'Negative Emotion',
      neutral: 'Neutral Emotion',
      interactionCountData: 'Interaction Count',
      capacity: 'Capacity',
      type: 'Type',
      person: 'Personal',
      memoryNum: 'memories',
      memory_config_name: 'Memory Engine',
      searchPlaceholder: 'Search memory store name',

      communityNetwork: 'Community Graph',
      community: 'Community',
      "Person": "Person Entity Node",
      "Organization": "Organization Entity Node",
      "ORG": "Organization Entity Node",
      "Location": "Location Entity Node",
      "LOC": "Location Entity Node",
      "Event": "Event Entity Node",
      "Concept": "Concept Entity Node",
      "Time": "Time Entity Node",
      "Position": "Position Entity Node",
      "WorkRole": "Work Role Entity Node",
      "System": "System Entity Node",
      "Policy": "Policy Entity Node",
      "HistoricalPeriod": "Historical Period Entity Node",
      "HistoricalState": "Historical State Entity Node",
      "HistoricalEvent": "Historical Event Entity Node",
      "EconomicFactor": "Economic Factor Entity Node",
      "Condition": "Condition Entity Node",
      "Numeric": "Numeric Entity Node",
      "Work": "Work / Output",
      member_count: 'Member Count',
      member_count_desc: 'entities',
      summary: 'Summary',
      core_entities: 'Core Entities',
      communityDetailEmptyDesc: 'Click on a community in the chart on the left to view details',
    },
    space: {
      createSpace: 'Create Space',
      enterSpace: 'Enter Space',
      spaceName: 'Space Name',
      spaceIcon: 'Space Icon',
      associated: 'Associated',
      notAssociated: 'Not Associated',
      storageType: 'Storage Type',
      rag: 'RAG Storage',
      ragDesc: 'Based on vector retrieval, suitable for document Q&A and semantic search',
      neo4j: 'Graph Storage',
      neo4jDesc: 'Based on knowledge graph, suitable for relational reasoning and path query',
      llmModel: 'LLM Model',
      embeddingModel: 'Embedding Model',
      rerankModel: 'Rerank Model',
      configAlert: 'Space model configuration ensures that the space can correctly call the corresponding models to process business data during runtime.',

      basic: 'Basic Config',
      models: 'Model Selection',
    },
    memoryExtractionEngine: {
      title: 'Memory Engine Module Configuration Center',
      subTitle: 'Configure the parameters of six core modules, and view in real-time the impact on the memory processing conclusions of the "sample memory text (insights from the technology conference)". Any parameter changes will be instantly reflected in the results area on the right.',
      example: 'Example Memory Text',
      storageLayerModule: 'Storage Layer Module',

      enableLlmDedupBlockwise: 'Entity De-duplication (LLM decision-making)',
      enableLlmDisambiguation: 'Memory Disambiguation Function (LLM decision)',
      tNameStrict: 'Name Matching Threshold',
      tTypeStrict: 'Type Matching Threshold',
      tOverall: 'Comprehensive Matching Threshold',

      arrangementLayerModule: 'Configuration Layer Module',
      queryMode: 'Query Mode',
      queryModeSubTitle: 'Control whether to activate deeper search functions',
      deepRetrieval: 'Deep Retrieval',
      deepRetrievalMeaning: 'Control whether to initiate deep memory retrieval (true/false).',
      dataPreprocessing: 'Data Preprocessing',
      dataPreprocessingSubTitle: 'Through reflection and refinement, transform episodic memory into deeper semantic memory.',

      entityDeduplicationModuleThreshold: 'Entity de-duplication - name matching threshold',

      variableName: 'Variable Name',
      control: 'Control',
      button: 'button',
      inputNumber: 'progress value',
      slider: 'Slider',
      select: 'select',
      location: 'Location',
      CurrentValue: 'Current Value',
      type: 'Type',
      Meaning: 'Meaning',

      exampleMemoryExtractionResults: 'Example Memory Extraction Results',
      exampleMemoryExtractionResultsSubTitle: '(from a technology conference)',

      extractTheNumberOfEntities: 'Extract the number of entities',
      extractTheNumberOfEntitiesDesc: 'Merge after deduplication: {{num}} (exact: {{exact}}, fuzzy: {{fuzzy}}, LLM: {{llm}})',

      numberOfEntityDisambiguation: 'Number of entity disambiguation',
      numberOfEntityDisambiguationDesc: 'Total {{num}} times (blocking: {{block_count}})',

      memoryFragments: 'Memory fragments',
      memoryFragmentsDesc: 'Split by paragraph + semantics',

      numberOfRelationalTriples: 'Number of relational triples',
      numberOfRelationalTriplesDesc: '{{num}} character relationships',

      entityDeduplicationImpact: 'Entity de-duplication impact',
      entityDeduplicationImpactDesc: 'Reduce {{count}} redundant entities to save storage space',
      identifyDuplicates: 'Identify duplicates',
      identifyDuplicatesDesc: '[{{name}}] appears {{appear_count}} times → merged into 1 entity [{{type}}]',

      recursiveChunker: 'Recursive Chunker',
      tokenChunker: 'Token Chunker',
      semanticChunker: 'Semantic Chunker',
      neuralChunker: 'Neural Chunker',
      hybridChunker: 'Hybrid Chunker',
      llmChunker: 'LLM Chunker',
      sentenceChunker: 'Sentence Chunker',
      lateChunker: 'Late Chunker',
      debug: 'Debug',
      model: 'Model',
      chunkerStrategy: 'Chunker Strategy',
      chunkerStrategyDesc: 'Choose a partitioning strategy.',
      intelligentSemanticPruning: 'Intelligent Semantic Pruning',
      intelligentSemanticPruningSubTitle: 'Whether to activate the intelligent semantic pruning function, select pruning scenarios, and set thresholds.',
      intelligentSemanticPruningFunction: 'Intelligent Semantic Pruning Function',
      intelligentSemanticPruningFunctionDesc: 'Whether to activate intelligent semantic pruning (true/false).',
      intelligentSemanticPruningScene: 'Intelligent Semantic Pruning Scene',
      intelligentSemanticPruningSceneDesc: 'Semantic pruning scenarios are consistent with ontology engineering scenarios',
      intelligentSemanticPruningThreshold: 'Intelligent Semantic Pruning Threshold',
      intelligentSemanticPruningThresholdDesc: 'Set intelligent semantic pruning threshold (0-0.9).',
      reflectionEngine: 'Self-Reflexion Engine',
      selfReflexionEngineSubTitle: 'Through reflection and refinement, transform episodic memory into deeper semantic memory.',
      enableSelfReflexion: 'Enable self-reflexion',
      iterationPeriod: 'Iteration Period',
      iterationPeriodDesc: 'Set the iteration period for self-reflexion (hourly, 3_hours, 6_hours, 12_hours, daily).',
      reflexionRange: 'Reflexion Range',
      reflexionRangeDesc: "When selecting 'Database', the iteration cycle is non configurable and fixed at daily",
      retrieval: 'Retrieval',
      database: 'Database',
      reflectOnTheBaseline: 'Reflect on the Baseline',
      basedOnTime: 'Based on time',
      basedOnFacts: 'Based on facts',
      basedOnFactsAndTime: 'Based on facts and time',
      oneHour: 'One hour',
      threeHours: 'Three hours',
      sixHours: 'Six hours',
      twelveHours: 'Twelve hours',
      daily: 'Daily',
      education: 'Education',
      online_service: 'Online service',
      outbound: 'Outbound',
      entityDeduplicationDisambiguation: 'Entity De-duplication Disambiguation',
      entityDeduplicationDisambiguationSubTitle: 'Control the LLM decision-making function for memory deduplication and disambiguation, set various matching thresholds, and affect the accuracy of memory deduplication.',
      semanticAnchorAnnotationModule: 'Semantic Anchor Annotation Module',
      semanticAnchorAnnotationModuleSubTitle: 'Control the granularity of statement extraction and whether to include dialog context.',
      statementGranularity: 'Statement Granularity',
      statementGranularityDesc: 'Statement extraction granularity (1-3): 1 represents breaking down sentences into different statements, 2 represents sentence level, and 3 represents merging sentences into paragraphs.',
      includeDialogueContext: 'Include Dialogue Context',
      includeDialogueContextDesc: 'Control whether the complete dialogue context is included in the extraction process (true/false).',
      maxDialogueContextChars: 'Max Dialogue Context Chars',
      maxDialogueContextCharsDesc: 'The maximum number of characters included in the dialogue context (to avoid character limit issues) (greater than 100).',
      coreEntitiesAfterDedup: 'Core entities after deduplication',
      extractRelationalTriples: 'Extracted relational triples (partial)',
      extractRelationalTriplesDesc: 'There are a total of {{count}} segments with clear semantic boundaries',
      theEffectOfEntityDisambiguationLLMDriven: 'The effect of entity disambiguation (LLM driven)',
      exampleText: `Student: What was the root cause of the Song dynasty’s military weakness?
Memory Bear: The Song dynasty’s military weakness mainly stemmed from institutional factors: the imperial guards were controlled by civil officials, which led to low combat efficiency; the regional armies were poorly equipped; military spending consumed more than half of the national budget for a long time, and constant warfare intensified fiscal pressure, which in turn restricted military development; its foreign strategy was passive, lacking strategic depth and mobility; and the dominance of civil officials suppressed military commanders, dispersing military authority and making it difficult to improve professionalization within the armed forces.

Student: I’m confused about the connection between fiscal pressure and insufficient military strength.
Memory Bear: Simply put, the Song government spent over half its budget on the military—costs kept rising, but the wars kept going badly. As military expenses dragged down the treasury, the court had to cut equipment and reduce troop numbers, which made the army even weaker. Losing battles meant having to spend more again to recruit troops, creating a vicious cycle.

Student: After the position of chancellor was abolished, what exactly went wrong with the bureaucracy?
Memory Bear: Abolishing the chancellor led to a rigid bureaucratic system, which manifested in several ways: central decision-making became highly concentrated in the emperor, reducing administrative efficiency; the Six Ministries lost the chancellor as their coordinating hub and lacked mechanisms for inter-departmental cooperation, making policy implementation difficult; surveillance agencies such as the Jinyiwei and the Eastern/Western Depots filled part of the gap, but since their focus was on monitoring and control, they intensified administrative tension; and officials selected through the imperial examination system were mostly scholars lacking systematic administrative training and specialization.

Student: I still don’t fully understand the specific impact of the “lack of coordination among the Six Ministries.”
Memory Bear: Originally, the chancellor functioned like a modern “prime minister,” and the Six Ministries were like today’s major government departments. Big or small, he coordinated everything. After the position was eliminated, the ministries reported directly to the emperor, but the emperor couldn’t possibly review everything himself, so they started passing responsibility around. For example, in wartime the Ministry of War needed funds, the Ministry of Revenue claimed it had none, and the Ministry of Works said it had no materials for weapons. With no one to make final decisions, military operations stalled.

Student: I’m reviewing the history of the Spring and Autumn and Warring States periods. I’m puzzled as to why Qin was able to unify the Six States, since the others were also strong.
Memory Bear: Qin succeeded for several reasons: Shang Yang’s reforms were thorough, establishing a legal system, household registration, and a military merit-based rank system that strengthened state capacity; the old aristocracy was weak, which allowed for a high degree of centralization; the Guanzhong region had superior geography—resource-rich, easy to defend, and difficult to invade; and from Duke Xiao to the First Emperor, Qin maintained strong policy continuity.

Student: Then switching to Tang history: after the An Lushan Rebellion, the central government began reforms, so why did regional warlordism (the fanzhen problem) actually get worse?
Memory Bear: After the rebellion, regional warlordism intensified for several reasons: military governors (jiedushi) held the power to recruit troops, control local finances, and command military forces, effectively becoming regional warlords; the central government’s finances declined due to the breakdown of the equal-field system and the collapse of the tax-labor system, making it increasingly unable to support the army, which pushed military forces to rely on the jiedushi; the recruitment-based military system made soldiers loyal to individual commanders rather than the state; eunuchs controlled the imperial guards, the civil bureaucracy lost influence, and the central government’s ability to balance regional power weakened.
`,

      warning: 'When you modify the configuration items on the left, click [Debug], and the extraction conclusions will be updated in real time here',
      processing: 'Configuration updated, re-extracting sample memory...',
      success: 'Memory extraction completed!',
      overallProgress: 'Overall Progress',
      text_preprocessing: 'Text Preprocessing',
      fragment: 'Fragment',
      knowledge_extraction: 'Knowledge Extraction',
      creating_nodes_edges: 'Creating Entity Relationships',
      deduplication: 'Deduplication and Disambiguation',
      status: {
        pending: 'Pending',
        processing: 'Processing',
        completed: 'Completed',
        failed: 'Failed'
      },
      time: 'Time: ',
      text_preprocessing_desc: 'Text split into {{count}} semantic fragments',
      knowledge_extraction_desc: 'Knowledge extraction completed, identified {{entities}} entities, {{statements}} statements, {{temporal_ranges_count}} temporal extractions, {{triplets}} triplets',
      creating_nodes_edges_desc: 'Entity relationship creation completed, {{num}} relationships in total',
      deduplication_desc: 'Deduplication and disambiguation completed, {{count}} unique entities in total',
      custom_text: 'Debug Text',
      ontologyCoverage: 'Ontology Type',
      entity_total: 'Total {{num}} entities',
      scene_type_distribution: 'Scene Type Distribution',
      general_type_distribution: 'General Type Distribution',
      unmatched: 'Unmatched',
      disagreementCase: 'Disagreement Case',
      Pruned: 'Pruned',
      pruning: 'Pruning',
      pruning_desc: 'Text pruning {{count}} fragments'
    },
    memoryConversation: {
      searchPlaceholder: 'Enter user ID...',
      chatEmpty:'Is there anything I can help you with？',
      userID: 'User ID',
      testMemoryConversation: 'Test Memory Conversation',
      conversationContent: 'Conversation Content',
      conversationContentEmpty: 'No conversation content available.',
      memoryConversationAnalysis: 'Memory Conversation Analysis',
      memoryFunction: 'Memory Function',
      onlineSearch: 'Online Search',
      deepThinking: 'Deep Thinking',
      MemoryFragmentsRecalled: 'Memory fragments recalled',
      MemoryRecallIndex: 'Memory recall index',
      comprehensiveEvaluation: 'Comprehensive evaluation',
      source: 'Source',
      relevance: 'Relevance',
      evaluation: 'Evaluation',
      memoryRecallRate: 'Memory recall rate',
      memoryAccuracy: 'Memory accuracy',
      answerFidelity: 'Answer fidelity',
      emptyDesc: 'What can I do to help you today？',
      startANewConversation: 'Start a new conversation',
      normalReply: 'Normal Reply',
      quickReply: 'Quick Reply',
      web_search: 'Online search',
      memory: 'Memory',
      memoryConversationAnalysisEmpty: 'No conversation analysis available.',
      memoryConversationAnalysisEmptySubTitle: 'Conversation analysis will appear here.',

      communities: 'Cluster Communities',
      summaries: 'Memory Summaries',
      uploadFile: 'Upload File',
      fileType: 'File Type',
      image: 'Image',
      video: 'Video',
      audio: 'Audio',
      fileUrl: 'File URL',
      addRemoteFile: 'Add Remote File',
      variableConfig: 'Variable Configuration',
    },
    login: {
      title: 'Red Bear Memory Science',
      subTitle: 'Every login is a reawakening of memories',
      intelligentMemory: 'Intelligent Memory',
      intelligentMemoryDesc: 'Let AI remember every conversation',
      instantRecall: 'Instant recall',
      instantRecallDesc: 'Accurately extract when needed',
      knowledgeAssociation: 'Knowledge association',
      knowledgeAssociationDesc: 'Build your knowledge graph',

      welcome: 'Welcome to Memory Science',
      loginIn: 'Login In',
      emailPlaceholder: 'Enter your email',
      passwordPlaceholder: 'Enter the password',
      rememberMe: 'Remember me',
      forgetPassword: 'Forget password?',
      usernamePlaceholder: 'Username',
      register: 'COMPLETE REGISTRATION',

      welcomeTeam: 'WELCOME TO THE TEAM',
      welcomeTeamSubTitle: 'You have received a team invitation. Please complete registration to start using the Red Bear Memory Science Platform',
      invitationVerified: 'Invitation verified',
      account: 'Account',
      emailAccount: 'Email account',
      emailAccountDesc: 'This email has been verified through the invitation link',
      setPassword: 'Set password',
      setPasswordPlaceholder: 'Please enter password (at least 8 characters)',
      setPasswordDesc: 'Password requirement: At least 8 characters, including uppercase and lowercase letters, numbers, and special characters (recommended)',
      confirmPassword: 'Confirm Password',
      confirmPasswordPlaceholder: 'Please enter your password again',
      name: 'Name',
      nameSubTitle: '(Optional, used for team member identification)',
      namePlaceholder: 'Please enter your name',
      inviteLinkInvalid: 'Invitation link is invalid',

      passwordStrength: 'Password strength',
      noSet: 'not set',
      lengthDesc: 'Please set at least 8 characters',
      strong: 'strong',
      medium: 'medium',
      mediumDesc: 'Medium password strength',
      weak: 'weak',
      weakDesc: 'The password strength is weak, please use a more complex password',
    },
    empty: {
      contentEmpty: 'The content is loading…',
      contentEmptyDesc: 'Your content is on its way by rocket! It will soon land on your screen',
      notFound: 'Oopps, your page is lost…',
      notFoundDesc: 'Try returning to the previous page',
      noPermission: 'Oh, this is an exclusive domain for permissions',
      noPermissionDesc: ' Please contact the administrator to grant permission',
      tableEmpty: 'No data available.',
      loadingEmpty: 'The content is loading…',
      loadingEmptyDesc: 'Your content is on its way by rocket! It will soon land on your screen',
      pageEmpty: 'Oops！ No search results available at the moment',
      pageEmptyDesc: "Red Bear tilts its head and waits for you to change a new keyword, let's explore together.",
    },
    apiKey: {
      name: 'Project Name',
      createApiKey: 'Create API Key',
      updateApiKey: 'Edit API Key',
      id: 'ID',
      created_at: 'Created At',
      description: 'Description',
      memoryEngine: 'Memory Engine',
      knowledgeBase: 'Knowledge Base',
      advancedSettings: 'Advanced Settings',
      expires_at: 'Expiration At',
      apiKey: 'API Key',
      status: 'Status',
      createdAt: 'Created At',
      expiresAt: 'Expires At',
      requestsPerMinute: 'Requests/Minute',
      viewDetail: 'View Details',
      disable: 'Disable',
      enable: 'Enable',
      baseInfo: 'Basic Information',
      permissionInfo: 'Permission Information',
      is_expired: 'Status',
      active: 'Active',
      inactive: 'Expired'
    },
    tool: {
      mcp: 'MCP Services',
      inner: 'Built-in Tools',
      custom: 'Custom Tools',
      market: 'Tool Market',
      mcpSearchPlaceholder: 'Search MCP Services...',
      innerSearchPlaceholder: 'Search Tools...',
      customSearchPlaceholder: 'Search Custom Tools...',
      addService: 'Add MCP Service',
      editService: 'Edit MCP Service',
      addServiceSuccess: 'Service added successfully',
      server_url: 'Service URL',
      last_health_check: 'Last Connection',
      responseTime: 'Response Time',
      status: {
        available: 'Available',
        unconfigured: 'Unconfigured',
        configured_disabled: 'Configured but Disabled',
        error: 'Connection Error'
      },
      available_desc: 'API is configured and enabled',
      unconfigured_desc: 'Need to configure API Key',
      configured_disabled_desc: 'API is configured but not enabled',
      error_desc: 'API is configured but connection error',

      testConnectionSuccess: 'Test Connection Successful',
      refreshSuccess: 'Refresh Successful',
      refreshFailed: 'Refresh Failed',
      
      // Market related
      marketSelectTitle: 'Select an MCP Market',
      marketSelectDesc: 'Choose a market source from the left, configure the connection to browse MCP services',
      marketRefreshSuccess: 'List refreshed',
      marketActivated: 'Activated',
      marketInDatabase: 'In Database',
      marketAdd: 'Add',
      marketRefresh: 'Refresh',
      marketConfigBtn: 'Configure',
      marketConfigConnection: 'Configure Connection',
      marketNoData: 'No Data',
      marketNoDataDesc: 'This market currently has no available services',
      marketNoSearchResult: 'No Search Results',
      marketNoSearchResultDesc: 'No matching services found, please try other keywords',
      marketNoServices: 'No MCP Services Available',
      marketNotConnected: 'Not Connected to This Market',
      marketNoServicesDesc: 'This market currently has no available services',
      marketNotConnectedDesc: 'Click the "Configure" button in the upper right corner to set connection information',
      marketSearchPlaceholder: 'Search services...',
      marketVisit: 'Visit Market',
      serviceEndpoint: 'Service Endpoint URL',
      serviceEndpointPlaceholder: 'URL of the service endpoint',
      serviceEndpointExtra: 'Complete access address of the MCP service',
      nameAndIcon: 'Name and Icon',
      namePlaceholder: 'Name your MCP service',
      serverIdentifier: 'Server Identifier',
      serverIdentifierPlaceholder: 'Unique server identifier, e.g. my-mcp-server',
      serverIdentifierLength: 'Maximum 24 characters',
      serverIdentifierPattern: 'Supports lowercase letters, numbers, underscores and hyphens',
      description: 'Description',
      auth: 'Authentication',
      requestHeader: 'Request Headers',
      config: 'Configuration',
      auth_type: 'Authentication Type',
      none: 'None',
      api_key: 'API Key',
      basic_auth: 'Basic Auth',
      bearer_token: 'Bearer Token',
      username: 'Username',
      password: 'Password',
      key_name: 'Key Name',
      requestHeaderDesc: 'Additional HTTP request headers sent to MCP server',
      addRequestHeader: 'Add Request Header',
      editRequestHeader: 'Edit Request Header',
      requestHeaderName: 'Request Header Name',
      requestHeaderValue: 'Request Header Value',
      timeout: 'Timeout (seconds)',
      sseReadTimeout: 'SSE Read Timeout (seconds)',
      saveAndTest: 'Save and Test',

      timeFormat: 'Time Formatting',
      timeZoneConversion: 'Time Zone Conversion',
      timestampConversion: 'Timestamp Conversion',
      timeCalculation: 'Time Calculation',
      time_desc: 'Date and Time Processing',
      DateTimeTool_features: 'Provides time format conversion, time zone conversion, timestamp calculation and other functions',
      currentTime: 'Current Time',
      timestamp: 'Timestamp',
      localTime: 'Local Time',
      utcTime: 'UTC Time',
      secondsTimestamp: 'Timestamp (seconds)',
      millisecondsTimestamp: 'Timestamp (milliseconds)',
      enterTimestamp: 'Enter Timestamp',
      conversion: 'Conversion',
      conversionResult: 'Conversion Result',
      chooseFormatType: 'Choose Format',

      JsonTool_desc: 'Data Format Conversion',
      JsonTool_features: 'JSON formatting, compression, validation and conversion functions',
      jsonParse: 'JSON Parse',
      jsonInsert: 'JSON Insert',
      jsonReplace: 'JSON Validation',
      jsonDelete: 'JSON Delete',
      jsonEg: 'Example JSON',
      enterJson: 'Enter JSON',
      jsonPlaceholder: 'Enter JSON data, e.g.: {"name": "test", "value": 123}',
      clear: 'Clear',
      paste: 'Paste',
      parse: 'Parse',
      json_path: 'JSON Path Parameters',
      outputResult: 'Output Result',
      validJosn: 'JSON format is correct, validation passed!',

      BaiduSearchTool_desc: 'Search Engine Service',
      BaiduSearchTool_features: 'Integrated Baidu Search API, providing web search, news search and other functions',
      webSearch: 'Web Search',
      newsSearch: 'News Search',
      imageSearch: 'Image Search',
      realTimeResults: 'Real-time Results',
      configStatus: 'Configuration Status',
      hasApiKey: 'API configured and enabled',
      needApiKey: 'Need to configure API Key',

      MinerUTool_desc: 'PDF Parsing Tool',
      MinerUTool_features: 'High-precision PDF document parsing tool, supports text, table, and image extraction',
      pdfParser: 'PDF Parser',
      tableExtraction: 'Table Extraction',
      imageRecognition: 'Image Recognition',
      textExtraction: 'Text Extraction',

      TextInTool_desc: 'OCR Text Recognition',
      TextInTool_features: 'Intelligent OCR text recognition service, supports multi-language and handwriting recognition',
      universalOCR: 'Universal OCR',
      handwritingRecognition: 'Handwriting Recognition',
      multilingualSupport: 'Multi-language Support',
      highPrecisionRecognition: 'High Precision Recognition',

      configDesc: 'Configuration Description',
      BaiduSearchTool_config_desc: 'To use Baidu Search API, you need to apply for API Key and Secret Key on Baidu Open Platform first.',
      MinerUTool_config_desc: 'MinerU is a high-precision PDF document parsing tool that requires an API Key to use.',
      TextInTool_config_desc: 'TextIn provides intelligent OCR text recognition service with multi-language support.',
      link: 'Application URL',
      BaiduSearchTool_api_key_desc: 'API Key obtained from Baidu Open Platform',
      MinerUTool_api_key_desc: 'API Key obtained from MinerU platform',
      secret_key: 'Secret Key',
      BaiduSearchTool_secret_key_desc: 'Secret Key obtained from Baidu Open Platform',
      TextInTool_secret_key_desc: 'Secret Key obtained from TextIn platform',
      type: 'Search Type',
      pagesize: 'Results Per Page',
      pagesize_desc: 'Number of results returned per search ({{count1}}-{{count2}})',
      BaiduSearchTool_enable: 'Enable Baidu Search',
      BaiduSearchTool_safe_enable: 'Enable Safe Search',
      BaiduSearchTool_safe_enable_desc: 'Filter inappropriate content',
      api_address: 'API Address',
      MinerUTool_api_address_desc: 'Uses official API address by default, can be modified if privately deployed',
      TextInTool_api_address_desc: 'Uses official API address by default',
      parsing_mode: 'Parsing Mode',
      auto_recognition: 'Auto Recognition',
      pure_text_mode: 'Pure Text Mode',
      table_priority: 'Table Priority',
      image_priority: 'Image Priority',
      MinerUTool_timeout_desc: 'PDF parsing timeout (10-300 seconds)',
      MinerUTool_enable: 'Enable MinerU',
      MinerUTool_extract_images_enable: 'Extract Images',
      MinerUTool_extract_images_enable_desc: 'Whether to extract image content from PDF',
      app_id: 'APP ID',
      TextInTool_app_id_desc: 'App ID obtained from TextIn platform',
      language_identification: 'Recognition Language',
      automatic_detection: 'Automatic Detection',
      simplified_chinese: 'Simplified Chinese',
      traditional_chinese: 'Traditional Chinese',
      english: 'English',
      japanese: 'Japanese',
      korean_language: 'Korean',
      pattern_recognition: 'Recognition Mode',
      universal_identification: 'Universal Recognition',
      high_precision_identification: 'High Precision Recognition',
      handwriting_recognition: 'Handwriting Recognition',
      formula_recognition: 'Formula Recognition',
      TextInTool_enable: 'Enable TextIn',
      return_text_position_enable: 'Return Text Position Info',
      return_text_position_enable_desc: 'Whether to return coordinate positions of recognized text',

      addCustom: 'Add Custom Tool',
      editCustom: 'Edit Custom Tool',
      schema: 'Schema',
      schemaPlaceholder: 'Enter your OpenAPI schema here',
      authentication: 'Authentication Method',
      tags: 'Tag',
      created_at: 'Created At',
      headerName: 'Header Name',
      null: 'None',
      tagDesc: 'Enter tags (comma-separated)',
      availableTools: 'Available Tools',
      name: 'Name',
      enterNamePlaceholder: 'Please enter a name',
      toolEmpty: 'No tools detected.',
      desc: 'Description',
      method: 'Method',
      path: 'Path',
      viewDetail: 'View Details',
      textLink: 'Test Connection',
      noResult: 'Processing results will be displayed here',

      marketConfig: 'Configure {{name}}',
      marketSaveAndConnect: 'Save & Connect',
      marketUrl: 'Market URL',
      marketUrlPlaceholder: 'Market URL',
      marketCopy: 'Copy',
      marketApiKeyOptional: 'Optional',
      marketApiKeyRequired: 'API Key is required',
      marketApiKeyExtra: 'Some markets require an API Key to access the full service list',
      marketApiKeyPlaceholder: 'Enter API Key to access more services',
      marketConnectionStatus: 'Connection Status',
      marketConnected: '● Connected',
      marketDisconnected: '○ Disconnected',
      marketConnecting: 'Connecting to {{name}}...',
      marketConfigUpdated: '{{name}} configuration updated',
      serverUrlInvalid: 'Must start with http:// or https://, and cannot have leading or trailing spaces',
      requestHeaderKeyInvalid: 'Only English letters, numbers, hyphens (-), and underscores (_) are allowed, and cannot start or end with a hyphen or underscore',
    },
    workflow: {
      coreNode: 'Core Nodes',
      start: 'Start',
      end: 'End',
      answer: 'Answer',
      aiAndCognitiveProcessing: 'AI & Cognitive Processing',
      llm: 'Large Language Model (LLM)',
      model_selection: 'Multi-Model Selection',
      model_voting: 'Multi-Model Voting',
      'knowledge-retrieval': 'Knowledge Retrieval (RAG)',
      classification: 'Intelligent Classification',
      'parameter-extractor': 'Parameter Extraction',
      flowControl: 'Flow Control',
      'if-else': 'Conditional Branch',
      'question-classifier': 'Question Classifier',
      iteration: 'Iteration',
      loop: 'Loop',
      'cycle-start': '',
      break: 'Break Loop',
      assigner: 'Variable Assignment',
      parallel: 'Parallel Execution',
      'var-aggregator': 'Variable Aggregator',
      externalInteraction: 'External Interaction',
      "http-request": 'HTTP Request',
      tool: 'Tools',
      code: 'Code Execution',
      "jinja-render": 'Template Rendering',
      cognitiveUpgrading: 'Cognitive Upgrading (Innovation)',
      'memory-read': 'Memory Retrieval',
      'memory-write': 'Memory Storage',
      task_planning: 'Task Planning',
      reasoning_control: 'Reasoning Control',
      self_reflection: 'Self Reflection',
      memory_enhancement: 'Memory Enhancement',
      agentCollaborationNode: 'Agent Collaboration Nodes',
      agent_scheduling: 'Agent Scheduling',
      agent_collaboration: 'Agent Collaboration',
      agent_arbitration: 'Agent Arbitration',
      safetyAndCompliance: 'Safety & Compliance',
      sensitive_detection: 'Sensitive Detection',
      output_audit: 'Output Audit',
      evolutionAndGovernance: 'Evolution & Governance',
      self_optimization: 'Self Optimization',
      process_evolution: 'Process Evolution',
      unknown: 'Unknown Node',
      notes: 'Sticky Note',

      clickToConfigure: 'Click to configure node parameters',
      nodeProperties: 'Node Properties',
      empty: "Emmm…The box is empty, there's nothing here～",
      nodeName: 'Node Name',
      addvariable: 'Chat Variables',
      addChatVariable: 'Add Chat Variable',
      editChatVariable: 'Edit Chat Variable',

      config: {
        llm: {
          model_id: 'Model',
          temperature: 'Temperature',
          max_tokens: 'Max Tokens',
          context: 'Context',
          contextPlaceholder: '{x} Set Variable',
          memory: 'Memory',
          enable_window: 'Memory Window',
          inner: 'Built-in',
          messagesPlaceholder: 'Write prompts here, type "{" to insert variables, type "insert" to insert',
          vision: 'Vision',
        },
        start: {
          variables: 'Input Fields',

          string: 'Text',
          number: 'Number',
          boolean: 'Checkbox',
          array: 'Dropdown Options',
          object: 'Object',

          editVariable: 'Edit Variable',
          variableType: 'Variable Type',
          variableName: 'Variable Name',
          invalidVariableName: 'Variable name can only start with English letters and contain English letters, numbers, and underscores',
          description: 'Display Name',
          default: 'Default Value',
          required: 'Required',
          max_length: 'Max Length',
          defaultChecked: 'Checked',
          notDefaultChecked: 'Unchecked',
          options: 'Options',
        },
        end: {
          output: 'Reply'
        },
        'knowledge-retrieval': {
          query: 'Query Variable',
          knowledge_retrieval: 'Knowledge Base',
          recallConfig: 'Recall Test',
          addKnowledge: 'Add Knowledge Base'
        },
        'parameter-extractor': {
          model_id: 'Model',
          text: 'Input Variable',
          textPlaceholder: '{x} Set Variable',
          params: 'Extract Parameters',
          prompt: 'Instruction',

          addParam: 'Add Extract Parameter',
          editParam: 'Edit Extract Parameter',

          name: 'Name',
          invalidParamName: 'Extract parameter name can only start with English letters and contain English letters, numbers, and underscores',
          type: 'Type',
          desc: 'Description',
          required: 'Required',
          default: 'Default Value',

          'string': 'String',
          'number': 'Number',
          'boolean': 'Boolean',
          'array[string]': 'Array[String]',
          'array[number]': 'Array[Number]',
          'array[boolean]': 'Array[Boolean]',
          'array[object]': 'Array[Object]',
          'object': 'Object',
          addParams: 'Add Extract Variable',
          promptPlaceholder: 'Write prompts here, type "{" to insert variables, type "insert" to insert',
        },
        'var-aggregator': {
          group: 'Aggregation Group',
          invalidVariableName: 'Variable name can only start with English letters and contain English letters, numbers, and underscores',
          addGroup: 'Add Group',
          variable: 'Variable Assignment'
        },
        'if-else': {
          "empty": 'Is Empty',
          "not_empty": 'Is Not Empty',
          "contains": 'Contains',
          "not_contains": 'Does Not Contain',
          "startwith": 'Starts With',
          "endwith": 'Ends With',
          "eq": 'Equals',
          "ne": 'Not Equals',
          num: {
            "eq": '=',
            "ne": '≠',
            "lt": '<',
            "le": '≤',
            "gt": '>',
            "ge": '≥',
          },
          boolean: {
            "eq": 'Is',
            "ne": 'Is Not',
          },
          else_desc: 'Used to define the logic that should be executed when the if condition is not met.'
        },
        'http-request': {
          auth: 'Authentication',
          authType: 'Auth Type',
          apiKey: 'API Key',
          basic: 'Basic',
          bearer: 'Bearer',
          custom: 'Custom',
          header: 'Header',
          api_key: 'API Key',
          timeouts: 'Timeout Settings',
          "connect_timeout": 'Connection Timeout (seconds)',
          "read_timeout": 'Read Timeout (seconds)',
          "write_timeout": 'Write Timeout (seconds)',
          retry: 'Retry on Failure',
          error_handle: 'Error Handling',
          verify_ssl: 'Verify SSL Certificate',
          none: 'None',
          default: 'Default Value',
          branch: 'Error Branch',
          status_code: 'Status Code',
          max_attempts: 'Max Retry Attempts',
          retry_interval: 'Retry Interval',
          errorBranch: 'Error Branch',
        },
        'jinja-render': {
          template: 'Code',
          mapping: 'Input Variables'
        },
        'question-classifier': {
          model_id: 'Model',
          input_variable: 'Input Variable',
          categories: 'Categories',
          user_supplement_prompt: 'Instruction',
          class_name: 'Classification',
          addClassName: 'Add Classification'
        },
        loop: {
          cycle_vars: 'Loop Variables',
          condition: 'Loop Termination Condition',
          addCondition: 'Add Condition',
          max_loop: 'Maximum Loop Count',
        },
        assigner: {
          assignments: 'Variables',
          cover: 'Override',
          assign: 'Set',
          clear: 'Clear',
          add: '+=',
          subtract: '-=',
          multiply: '*=',
          divide: '/=',
        },
        iteration: {
          input: 'Input Variable',
          output: 'Output Variable',
          parallel: 'Parallel Mode',
          parallel_count: 'Max Parallelism',
          flatten: 'Flatten Output',
        },
        tool: {
          tool_id: 'Tool',
        },
        'memory-read': {
          message: 'Message',
          config_id: 'Memory Configuration',
          search_switch: 'Search Mode',
        },
        'memory-write': {
          messages: 'Message',
          config_id: 'Memory Configuration',
          search_switch: 'Search Mode',
        },

        'code': {
          input_variables: 'Input Variables',
          output_variables: 'Output Variables',
          refreshTip: 'Sync function signature to code',
        },
        notes: {
          showAuth: 'Show Author',
          enterLink: 'Enter Link URL',
          placeholder: 'Enter note...',
          removeLink: 'Remove Link',
        },
        name: 'Key',
        type: 'Type',
        value: 'Value',
        addCase: 'Add Condition',
        addVariable: 'Add Variables',
        output: 'Output Variable'
      },

      clear: 'Clear',
      run: 'Run',
      save: 'Save',
      export: 'Export',
      variableConfig: 'Variable Configuration',
      variableRequired: 'Required, please configure variable values',
      addMessage: 'Add Message',
      answerDesc: 'Reply',
      addNode: 'Add Node',
      arrange: 'Arrange',
      redo: 'Redo',
      undo: 'Undo',

      input: 'Input',
      output: 'Output',
      error: 'Error Message',
      loopNum: ' loops',
      iterationNum: ' iterations',
      runtime: {
        loop: 'Loop',
        iteration: 'Iteration',
        input_cycle_vars: 'Initial Loop Variables',
        output_cycle_vars: 'Final Loop Variables',
      }
    },
    emotionEngine: {
      emotionEngineConfig: 'Emotion Engine Configuration',

      emotion_enabled: 'Enable Emotion Engine',
      emotion_enabled_desc: 'Automatically analyze emotional tendencies in conversations',

      emotion_model_id: 'Emotion Analysis Model',
      emotion_model_id_desc: 'Different models vary in accuracy and speed',

      emotion_extract_keywords: 'Emotion Keyword Extraction',
      emotion_extract_keywords_subTitle: 'Automatically extract emotion-related keywords from conversations',
      emotion_extract_keywords_desc: 'Extract emotional keywords like "happy", "disappointed", "excited" to better understand user emotions',
      emotion_min_intensity: 'Confidence Threshold',
      emotion_min_intensity_desc: 'Higher confidence leads to more accurate recognition, but may miss some information',

      emotion_enable_subject: 'Emotion Subject Classification',
      emotion_enable_subject_subTitle: 'Identify emotion attribution (self/other/object)',
      emotion_enable_subject_desc: 'Distinguish emotion subjects: self (I feel happy), other (he is angry), object (this product is great)',

      currentValue: 'Current Value',
      emotion_min_intensity_description: 'Confidence Threshold Description',
      question: 'What is Confidence Threshold?',
      answer: 'Confidence threshold is the "certainty level" standard for emotion engine to judge emotions. When the emotional confidence analyzed by AI is lower than the set threshold, the emotion will not be recorded.',
      differentTitle: 'Impact of Different Thresholds',
      advantage: 'Advantages',
      shortcoming: 'Disadvantages',
      scene: 'Applicable Scenarios',
      low_title: 'Low Threshold (0.0 - 0.4)',
      low_tag: 'Sensitive',
      low_advantage: 'Can capture more subtle emotional changes without missing potential emotional signals',
      low_shortcoming: 'May cause misjudgments, identifying neutral or unclear expressions as specific emotions',
      low_scene: 'Scenarios requiring comprehensive understanding of user emotional fluctuations with low accuracy requirements',
      middle_title: 'Medium Threshold (0.5 - 0.7)',
      middle_tag: 'Recommended',
      middle_advantage: 'Balances accuracy and coverage, can identify obvious emotions without being overly sensitive',
      middle_shortcoming: 'May miss some less obvious emotional expressions',
      middle_scene: 'Most daily conversation scenarios, suitable for general emotional analysis needs',
      high_title: 'High Threshold (0.8 - 1.0)',
      high_tag: 'Precise',
      high_advantage: 'Only records very clear emotional expressions, extremely high accuracy with low misjudgment rate',
      high_shortcoming: 'Will miss a large amount of less obvious emotional information, low data coverage',
      high_scene: 'Scenarios requiring extremely high accuracy, such as emotional crisis warnings and important decision references',

      configSuggest: 'Configuration Suggestions',
      first: 'First Time Use',
      first_desc: 'Recommend starting with medium threshold (0.6-0.7), observe for a period and adjust based on actual results',
      customer_service: 'Customer Service Scenarios',
      customer_service_desc: 'Recommend using lower threshold (0.4-0.6) to timely capture user dissatisfaction',
      data_analysis: 'Data Analysis',
      data_analysis_desc: 'Recommend using medium threshold (0.6-0.7) to ensure data quality while having sufficient sample size',
      risk_warning: 'Risk Warning',
      risk_warning_desc: 'Recommend using higher threshold (0.7-0.8) to ensure warning accuracy',

      actual_case: 'Actual Case',
      user_input: 'User Input',
      user_input_message: '"This feature is okay, but there are some minor issues"',
      neutral_emotion: 'Neutral Emotion',
      neutral_emotion_tag: 'All thresholds will record',
      minor_dissatisfaction: 'Minor Dissatisfaction',
      minor_dissatisfaction_tag: 'Only low/medium thresholds will record',
      expect_improvement: 'Expect Improvement',
      expect_improvement_tag: 'Only low threshold will record',
      confidence: 'Confidence'
    },
    statementDetail: {
      wordCloud: 'Emotion Distribution Analysis',
      totalCount: 'Sample Count',
      pieces: 'items',
      emotionTags: 'High-Frequency Emotion Keywords',
      joy: 'Joy',
      anger: 'Anger',
      sadness: 'Sadness',
      fear: 'Fear',
      neutral: 'Neutral',
      surprise: 'Surprise',

      health: 'Emotional Health Index',
      positivity_rate: 'Positivity Rate',
      stability: 'Stability',
      resilience: 'Resilience',
      suggestions: 'Personalized Suggestions',
      suggestionLoading: 'Your personalized suggestions are being generated',
      item: 'item',
      noData: 'Emotion suggestion data does not exist, please click the refresh button to initialize',
    },
    reflectionEngine: {
      reflectionEngineConfig: 'Reflection Engine Configuration',
      reflection_enabled: 'Enable Reflection Engine',
      reflection_enabled_desc: 'Transform episodic memory into semantic memory, forming long-term cognition',
      reflection_model_id: 'Reflection Model',
      reflection_model_id_desc: 'Different models vary in accuracy and speed',
      reflection_period_in_hours: 'Iteration Period',
      reflection_period_in_hours_desc: 'Determines how often the system performs memory reflection and refinement',
      reflexion_range: 'Reflection Range',
      partial: 'Partial Reflection (New memories only)',
      all: 'Full Reflection (All historical memories)',
      reflexion_range_desc: '',
      baseline: 'Reflection Baseline',
      baseline_desc: '',
      TIME: 'Time-based (Temporal relationships)',
      FACT: 'Fact-based (Knowledge points)',
      HYBRID: 'Fact + Time (Comprehensive dimension)',
      quality_assessment: 'Enable Quality Assessment',
      quality_assessment_desc: 'Automatically evaluate memory accuracy, completeness and timeliness',
      memory_verify: 'Enable Memory Verification',
      memory_verify_desc: 'Detect sensitive information and filter inappropriate content',
      oneHour: 'Every 1 hour',
      threeHours: 'Every 3 hours',
      sixHours: 'Every 6 hours',
      twelveHours: 'Every 12 hours',
      daily: 'Daily',
      run: 'Run Debug',
      example: 'Raw Data',
      exampleText: 'I went to Beijing for work in the spring of 2023, and have basically been working in Beijing ever since, without changing cities much. However, due to company restructuring, I was transferred to Shanghai for about half a year in the first half of 2024, during which time I checked in at the Shanghai office every day. At that time, my employment records still used my previous identity information, with ID number 11010119950308123X and bank card 6222023847595898, which have never changed. By the way, I have actually been living in Beijing since 2023 and have never left Beijing for long periods. The Shanghai period was more like remote collaboration.',
      runTitle: 'Reflection Test Run',
      status: 'Status',
      message: 'Message',

      conflictDetection: 'Conflict Detection',
      reason: 'Conflict Reason',
      solution: 'Solution',

      qualityAssessment: 'Quality Assessment',
      qualityAssessmentObj: {
        score: 'Quality Score',
        summary: 'Assessment Summary',
      },

      privacyAudit: 'Privacy Audit',
      privacyAuditObj: {
        true: 'Yes',
        false: 'No',
        has_privacy: 'Contains Privacy Information',
        privacy_types: 'Privacy Types',
        summary: 'Audit Summary',
      }
    },
    pricing: {
      title: 'Flexible Pricing for Teams of All Sizes',
      desc: 'Transparent pricing that helps you easily find a plan that fits your budget.',
      solution: 'Product Positioning',
      targetAudience: 'Target Audience',
      orderPayment: 'Order Payment',
      creationTime: 'Creation Time',
      orderPaymentDesc: 'Please confirm the order information and complete the payment.',
      orderInformation: 'Order Information',
      paymentMethod: 'Payment Method',
      paymentVoucher: 'Payment Voucher',
      corporateTransfer: 'Corporate transfer',
      corporateTransferDesc: 'Pay via corporate bank transfer.',
      payeeInformation: 'Payee Account Information',
      receivingEntity: 'Receiving Entity',
      bankName: 'Bank Name',
      bankAccountNumber: 'Bank Account Number',
      pay_txn_id: 'Payment Transaction ID',
      pay_txn_idPlaceholder: 'Please enter the bank transfer transaction ID.',
      pay_txn_idDesc: 'Please fill in the serial number on the bank transfer voucher for verification of payment',
      payer: 'Payer(Company/Individual)',
      payerPlaceholder: 'Please enter the bank transfer transaction ID.',
      redirectCountdown: 'seconds until redirecting to Memory Bear...',
      confirmRedirect: 'Payment voucher submitted successfully!',
      confirmRedirectContent: 'We will verify your payment information within 1-3 business days. Would you like to go to Memory Bear now to start your experience?',
      stayCurrentPage: 'Stay on current page',
      goBack: 'Go to backend',
      transferDate: 'Transfer Date',
      payerAccount: 'Payer Account',
      remark: 'Remark',
      remarkPlaceholder: 'Please provide any additional remarks here (optional).',
      confirm: 'SUBMIT PAYMENT',
      submitting: 'Submitting...',
      payInfo: 'After submission, we will verify your payment information within 1–3 business days.',
      paySuccess: 'Once verified, your subscription service will be automatically activated by the system.',
      comboName: 'Combo Name',
      spAndTa: 'Solution positioning and target audience',
      versionInformation: 'Version information',
      orderCycle: 'Order Cycle',
      orderAmount: 'Order Amount',
      personal: {
        type: 'Personal',
        label: 'Current Package',
        typeDesc: 'For Individuals',
        solution: "A person's second brain, capable of storing up to 2000 memories.",
        targetAudience: 'individual users, students, and first-time users',
        priceDesc: '/Free forever',
        supportServices: 'Community Forum + Email Support',
      },
      team: {
        type: 'Team',
        label: 'Small Team',
        typeDesc: 'For Small Teams',
        solution: "Enable every team to build a shared second brain in seconds.",
        targetAudience: 'Small teams, early-stage startups, and small projects.',
        priceDesc: '/month',
        supportServices: 'Standard customer service support',
      },
      biz: {
        type: 'Biz+',
        label: 'Most Popular',
        typeDesc: 'Enterprise Growth Plan',
        solution: "Scale your organization with a powerful, enterprise-ready second-brain system.",
        targetAudience: 'Growing teams, startups, and SMBs requiring advanced memory capabilities.',
        priceDesc: '/per workspace / month',
        supportServices: 'Priority customer service support',
      },
      commerce: {
        type: 'Commerce',
        label: 'Commercial OEM',
        typeDesc: 'Commercial OEM plan',
        solution: "Seamlessly integrate advanced memory capabilities into your SaaS or enterprise product.",
        targetAudience: 'Large enterprises, SaaS vendors, and system integrators requiring fully customizable and secure deployment.',
        priceDesc: 'On-premises deployment',
        supportServices: 'Standard customer service support',
        flexibleDeployment: 'Supports localized deployment in data centers',
        reliableGuarantee: '99.9% SLA guarantee'
      },
      mostPopular: 'Most Popular',
      startedBtn: 'GET STARTED',
      choosePlanBtn: 'CHOOSE PLAN',
      contactBtn: 'CONTACT US',
      memoryCapacity: 'Memory capacity:',
      entries: 'entries',
      intelligentSearchFrequency: 'Intelligent search frequency:',
      timesMonth: 'times/month',
      supportServices: 'Support Services:',
      flexibleDeployment: 'Flexible deployment:',
      reliableGuarantee: 'Reliable guarantee:',
      alertTitle: 'Third-Party API Usage Notice',
      alertContent: "Please note: Some AI models(such as GPT- 4, Claude, etc.) may incur third- party API usage fees.These fees are not included in your Memory Bear subscription and must be paid directly to the model provider. Memory Bear charges only for platform management and related services and does not cover or assume responsibility for any third- party API usage fees.",
      currentAccountType: 'Current Account Type',
      validUntil: 'Valid Until',
      orderHistory: 'Order History',
      order_no: 'Order Number',
      product_type: 'Package Name',
      payable_amount: 'Order Amount',
      status: 'Order Status',
      pay_time: 'Payment Time',
      viewDetail: 'View Details',
      PENDING: 'Pending Review',
      APPROVED: 'Approved',
      REJECTED: 'Rejected',
      allStatus: 'All Status',
      allTime: 'All Time',
      today: 'Today',
      week: 'Last Week',
      month: 'Last Month',
      threeMonth: 'Last Three Months',
      year: 'Last Year',
      searchPlaceholder: 'Search order number',
      allType: 'All Packages',
      orderDetail: 'Order Details',
      orderInfo: 'Order Information',
      orderPayInfo: 'Payment Information',
      create_time: 'Creation Time',
    },
    forgetDetail: {
      title: 'The forgetting management system helps AI intelligently manage memory lifecycle by automatically identifying low-value memories, setting forgetting strategies, and executing regular cleanup to optimize memory storage space and improve retrieval efficiency.',
      overviewTitle: 'Core Metrics Overview',
      totalMemory: 'Total Memory',
      MemoryHealth: 'Memory Health',
      riskOfForgetting: 'Forgetting Risk',
      statement_count: 'Statements',
      entity_count: 'Entities',
      summary_count: 'Summaries',
      chunk_count: 'Chunks',
      healthStatus: 'Health Status',
      average: 'Average Activation Value',
      threshold: 'Threshold Reference:',
      unhealthy: 'Unhealthy',
      healthy: 'Healthy',
      low_nodes: 'Low Activation Nodes',
      memoryHealthVisualization: 'Memory Health Visualization',
      activationValueDistribution: 'Activation Value Distribution',
      forgettingTrend: 'Forgetting Trend (Last 7 Days)',

      nodes_without_activation: 'Observation Zone',
      low_activation_nodes: 'Forgetting Zone',
      health_nodes: 'Healthy Zone',
      average_activation: 'Average Activation Value',
      merged_count: 'Daily Merged Node Count',

      pending_nodes: 'Risk Node Forgetting Pool',
      content_summary: 'Content Summary',
      node_type: 'Node Type',
      last_access_time: 'Last Activation Time',
      activation_value: 'Current Activation Value',
      refreshSuccess: 'Forgetting Execution Successful',
    },
    episodicDetail: {
      title: 'Record every important scene you have truly experienced',
      total_all: 'Total Episodic Memories',
      all: "All",
      today: 'Today',
      this_week: 'This Week',
      this_month: 'This Month',
      conversation: "Conversation",
      project_work: "Project/Work",
      learning: "Learning",
      decision: "Decision",
      important_event: "Important Event",
      titleKeywordPlaceholder: 'Search episode title or content',
      curResult: 'Current Filter Results',
      unix: 'items',
      created: 'Occurrence Time',
      episodic_type: 'Episode Type',
      involved_objects: 'Involved Objects',
      content_records: 'Episode Content Records',
      emotion: 'Emotion and State Records',
      none: 'None',
    },
    implicitDetail: {
      title: 'The invisible forces that shaped me',
      preferences: 'My Subconscious Preferences',
      preferencesDetail: 'Association Network',
      portraitTitle: 'My Subconscious Portrait',
      portraitSubTitle: 'Personalized insights generated by AI based on your preference tags',
      portrait: 'Core Traits',
      aesthetic: 'Aesthetic Driven',
      creativity: 'Creative Thinking',
      literature: 'Cultural Sensitivity',
      technology: 'Technology Affinity',
      interestAreas: 'Interest Area Distribution',
      art: 'Art & Design',
      music: 'Music & Culture',
      tech: 'Technology & Future',
      lifestyle: 'Lifestyle',
      habits: 'User Habit Analysis',
      habitsSubTitle: 'Habit characteristics identified based on your behavior patterns',
      context_details: 'Preference Details',
      supporting_evidence: 'Preference Source',
      specific_examples: 'Source',
      wordEmpty: 'Click on a node in the left chart to view preference details',
      noData: 'Portrait data does not exist, please click the refresh button to initialize',
    },
    shortTermDetail: {
      title: 'Short-term memory is the "workbench" of the AI system, connecting instant conversations with long-term knowledge bases. Through real-time capture, deep retrieval, intelligent extraction and filtering transformation, temporary unstructured information is converted into valuable long-term knowledge.',
      retrieval_number: 'Retrieval Count',
      entity: 'Extracted Entities',
      long_term_number: 'Long-term Candidates',
      shortTermTitle: 'Deep Retrieval & Extended Answer Area',
      shortTermSubTitle: 'Stores deep information retrieval performed to answer questions and the extended answers generated from it, including original questions, retrieved information, and generated answers.',
      longTermTitle: 'Long-term Memory Candidate Pool',
      longTermSubTitle: 'Aggregates short-term memory, filters and prepares content for storage in long-term memory. This is the "transfer station" and "filter" from short-term to long-term memory.',
      answer: 'Answer',
      query: 'Question',
      noAnswer: 'No reply yet',
    },
    perceptualDetail: {
      last_visual: 'Visual Perception Stream',
      last_listen: 'Auditory Perception Stream',
      last_text: 'Text Perception',
      summary: 'Summary',
      keywords: 'Keywords',
      topic: 'Topic',
      domain: 'Domain',
      scene: 'Scene',
      speaker_count: 'Number of Speakers',
      section_count: 'Number of Sections',
      timeLine: 'Perception Timeline',
      lastInfo: 'Real-time Perception Dashboard',
    },
    explicitDetail: {
      episodic_memories: 'Episodic Memories',
      semantic_memories: 'Semantic Memories',
      content: 'Core Description',
      created_at: 'Created At',
      emotion: 'Emotion',
      core_definition: 'Core Definition',
      detailed_notes: 'Detailed Notes',
    },
    workingDetail: {
      conversationStream: 'Real-time Conversation Stream',
      refresh: 'Refresh',
      successfulTitle: 'Successful Experience',
      question: 'Lessons Learned',
      summary: 'Core Insights',
      none: 'None'
    },
    ontology: {
      searchPlaceholder: 'Search scenarios',
      create: 'Create Project',
      edit: 'Edit Project',
      scene_name: 'Scenario Name',
      scene_description: 'Scenario Description',
      descriptionPlaceholder: 'Describe the purpose of this scenario and the entity types to extract',
      typeCount: 'types',
      created_at: 'Created At',
      updated_at: 'Updated At',
      entityTypes: 'Entity Types',

      classSearchPlaceholder: 'Search types',
      addClass: 'Add Type',
      class_name: 'Type Name',
      class_description: 'Type Definition',
      classDescriptionPlaceholder: 'Describe the meaning and purpose of this type',

      llm_id: 'Select Model',
      scenario: 'Scenario Description',
      scenarioPlaceholder: 'Please describe your business requirements',
      run: 'Inference',
      loadingConfirm: 'Inferring',
      extractConfirm: 'Add Selected Types',
      classType: 'Project Type',
      extract: 'Project Inference',
      source: 'Not Added',
      target: 'Added',
      import: 'Import Scenario',
      format: 'Export Format',
      export: 'Export Scenario',
      scene_id: 'Scenario',
      file: 'Import File',
    },
    prompt: {
      editor: 'Prompt Generator',
      history: 'My History',
      historySearchPlaceholder: 'Search by name',
      model: 'Model',
      you: 'You',
      ai: 'AI Assistant',
      promptPlaceholder: 'Conversation optimization prompt will be displayed here',
      promptChatEmpty: 'No conversation content available',
      promptChatPlaceholder: 'Describe the prompt you need, e.g.: I need a customer service assistant',
      conversationOptimizationPrompt: 'Conversation Optimization Prompt',
      addVariable: 'Insert Variable',
      initialInput: 'Original Input',
      saveTitle: 'Title',
    },
    skills: {
      searchPlaceholder: 'Search skills',
      create: 'Add Skill',
      mainfest: 'Define Encapsulation Container',
      name: 'Skill Name',
      description: 'Brief Description',
      descriptionPlaceholder: 'Describe the intent and purpose of the skill...',
      keywords: 'Keywords',
      promptConfiguration: 'Inject Experience Logic',
      aiPrompt: 'AI Experience Refinement',
      prompt_type: 'System Instructions / Expert Knowledge',
      promptPlaceholder: 'Enter system instructions or expert knowledge...',
      save: 'Save',
      AIPromptAssistant: 'AI Experience Refinement',
      model: 'Model',
      promptChatEmpty: 'No conversation content available',
      you: 'You',
      ai: 'AI Assistant',
      promptChatPlaceholder: 'Describe your requirements...',
      conversationOptimizationPrompt: 'Refined Content',
      apply: 'Apply',
      tools: 'Tools',
    },
  },
};
