@jjlmoya/utils-developer 1.4.0 → 1.5.0

package/src/tool/llmCostCalculator/i18n/nl.ts

@@ -0,0 +1,166 @@
+import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { LlmCostCalculatorUI } from '../ui';
+
+const slug = 'llm-cost-calculator-nl';
+const title = 'LLM Kostencalculator. Prijsschatter voor AI Model APIs';
+const description =
+  'Gratis online tool om de kosten van LLM API-aanroepen te schatten. Vergelijk GPT-4o, Claude, Gemini, Llama en meer met echte tokenprijzen per miljoen tokens.';
+
+const faqData = [
+  {
+    question: 'Hoe worden de kosten van een LLM API berekend?',
+    answer:
+      'LLM APIs rekenen afzonderlijk voor invoer-tokens (de prompt) en uitvoer-tokens (het antwoord). De totale kosten per verzoek zijn: (invoer-tokens × invoerprijs + uitvoer-tokens × uitvoerprijs) / 1.000.000. Vermenigvuldig dit met het aantal verzoeken om de totale maandelijkse kosten te berekenen.',
+  },
+  {
+    question: 'Wat zijn tokens en hoe verhouden ze zich tot woorden?',
+    answer:
+      'Een token is de basiseenheid van tekst die een taalmodel verwerkt. Gemiddeld is 1 token gelijk aan ongeveer 0,75 woord in het Engels, dus 1.000 tokens ≈ 750 woorden. Prijzen worden opgegeven per miljoen tokens ($/1M), de standaard prijseenheid bij alle aanbieders.',
+  },
+  {
+    question: 'Waarom zijn uitvoer-tokens duurder dan invoer-tokens?',
+    answer:
+      'Bij het genereren van tekst (uitvoer) moet het model elke token achtereenvolgens berekenen, wat rekenintensief is dan het lezen van de invoer. De meeste aanbieders rekenen 3 tot 5 keer meer voor uitvoer-tokens dan voor invoer-tokens.',
+  },
+  {
+    question: 'Hoe kan ik mijn LLM API-kosten verlagen?',
+    answer:
+      'Gebruik het kleinste model dat voldoet aan jouw kwaliteitseisen. Sla herhaalde prompts op in een cache wanneer mogelijk. Houd de systeemprompt zo kort mogelijk en vermijd onnodige context. Voor eenvoudige classificatie- of extractietaken bieden kleinere modellen zoals GPT-4o mini of Gemini Flash aanzienlijke besparingen.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Selecteer een model',
+    text: 'Kies het AI-model dat je wilt gebruiken uit de gegroepeerde keuzelijst. Modellen zijn georganiseerd per aanbieder.',
+  },
+  {
+    name: 'Voer het aantal tokens in',
+    text: 'Voer het verwachte aantal invoer-tokens (jouw prompt) en uitvoer-tokens (het antwoord) in. Onder elk veld verschijnt een schatting in woorden.',
+  },
+  {
+    name: 'Stel het aantal verzoeken in',
+    text: 'Gebruik de schuifregelaar of het getalveld om in te voeren hoeveel API-aanroepen je verwacht. De totale kosten worden realtime bijgewerkt.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowToThing> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'DeveloperApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  inLanguage: 'nl',
+};
+
+const ui: LlmCostCalculatorUI = {
+  labelModel: 'LLM-model',
+  labelInputTokens: 'Invoer tokens',
+  labelOutputTokens: 'Uitvoer tokens',
+  labelRequests: 'Aantal verzoeken',
+  unitWords: 'woorden',
+  labelCostPerRequest: 'Kosten per verzoek',
+  labelTotal: 'Geschatte totale kosten',
+  labelInput: 'Invoer',
+  labelOutput: 'Uitvoer',
+};
+
+export const content: ToolLocaleContent<LlmCostCalculatorUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faqTitle: 'Veelgestelde vragen',
+  faq: faqData,
+  bibliographyTitle: 'Bronnen en prijsreferenties',
+  bibliography: [
+    {
+      name: 'OpenAI API-prijzen',
+      url: 'https://openai.com/pricing',
+    },
+    {
+      name: 'Anthropic API-prijzen',
+      url: 'https://www.anthropic.com/pricing',
+    },
+    {
+      name: 'Google AI Studio prijzen',
+      url: 'https://ai.google.dev/pricing',
+    },
+    {
+      name: 'OpenAI Tokenizer',
+      url: 'https://platform.openai.com/tokenizer',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'LLM API-prijzen begrijpen',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'APIs voor grote taalmodellen rekenen op basis van tokengebruik, niet op basis van tijd of het aantal verzoeken. Elke API-aanroep heeft twee kostencomponenten: de <strong>invoerkosten</strong> (verwerking van jouw prompt) en de <strong>uitvoerkosten</strong> (generatie van het antwoord). Dit onderscheid begrijpen is de sleutel tot een nauwkeurige schatting van je maandelijkse rekening.',
+    },
+    {
+      type: 'title',
+      text: 'Invoer tokens versus uitvoer-tokens',
+      level: 3,
+    },
+    {
+      type: 'grid',
+      columns: 2,
+    },
+    {
+      type: 'card',
+      title: 'Invoer tokens',
+      html: '<p>Invoer tokens vertegenwoordigen alles wat <strong>naar</strong> het model wordt gestuurd: jouw systeemprompt, de gespreksgeschiedenis en het gebruikersbericht. Ze zijn goedkoper omdat het model ze parallel verwerkt. Een typische systeemprompt van 200 woorden kost ongeveer 267 invoer-tokens.</p>',
+    },
+    {
+      type: 'card',
+      title: 'Uitvoer tokens',
+      html: '<p>Uitvoer tokens worden één voor één achtereenvolgens gegenereerd, wat ze rekenintensief maakt. De meeste aanbieders rekenen <strong>3 tot 5 keer meer</strong> voor uitvoer-tokens. Een antwoord van 300 woorden genereert ongeveer 400 uitvoer-tokens. Antwoorden beknopt houden is een van de meest effectieve strategieën om kosten te besparen.</p>',
+    },
+    {
+      type: 'title',
+      text: 'Het juiste model kiezen voor jouw budget',
+      level: 3,
+    },
+    {
+      type: 'tip',
+      html: 'Begin met een capabel middenklasse model zoals <code>GPT-4o mini</code> of <code>Gemini 1.5 Flash</code> en schakel alleen over naar een groter model als de kwaliteit tekortschiet. Het kostenverschil tussen een klein en groot model kan 10 tot 100 keer zijn.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Niet alle taken vereisen dezelfde modelkwaliteit. Classificatie, extractie en samenvattingen werken vaak prima met kleinere, goedkopere modellen. Bewaar grote frontier-modellen zoals <code>claude-3-opus</code> of <code>o1</code> voor complexe redeneeruitgaven waarbij kwaliteit direct het resultaat beïnvloedt.',
+    },
+  ],
+};
+

package/src/tool/llmCostCalculator/i18n/pl.ts

@@ -0,0 +1,165 @@
+import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { LlmCostCalculatorUI } from '../ui';
+
+const slug = 'kalkulator-kosztow-llm';
+const title = 'Kalkulator Kosztów LLM. Estymator Cen Modeli AI';
+const description =
+  'Bezpłatne narzędzie online do oszacowania kosztów wywoływania interfejsów API LLM. Porównuj GPT-4o, Claude, Gemini, Llama i inne z rzeczywistymi cenami tokenów za milion tokenów.';
+
+const faqData = [
+  {
+    question: 'Jak obliczany jest koszt interfejsu API LLM?',
+    answer:
+      'Interfejsy API LLM pobierają opłaty oddzielnie za tokeny wejściowe (prompt) i tokeny wyjściowe (odpowiedź). Całkowity koszt na żądanie to: (tokeny wejściowe × cena wejściowa + tokeny wyjściowe × cena wyjściowa) / 1 000 000. Pomnóż przez liczbę żądań, aby uzyskać całkowity miesięczny koszt.',
+  },
+  {
+    question: 'Co to są tokeny i jak się mają do słów?',
+    answer:
+      'Token to podstawowa jednostka tekstu, którą przetwarza model językowy. Przeciętnie 1 token równa się około 0,75 słowa w języku angielskim, więc 1000 tokenów ≈ 750 słów. Ceny są podawane za milion tokenów ($/1M), co jest standardową jednostką cen na wszystkich platformach.',
+  },
+  {
+    question: 'Dlaczego tokeny wyjściowe są droższe niż tokeny wejściowe?',
+    answer:
+      'Generowanie tekstu (wyjście) wymaga, aby model obliczył każdy token sekwencyjnie, co jest bardziej intensywne obliczeniowo niż czytanie wejścia. Większość dostawców pobiera 3-5 razy więcej za tokeny wyjściowe niż tokeny wejściowe.',
+  },
+  {
+    question: 'Jak mogę zmniejszyć koszty API LLM?',
+    answer:
+      'Użyj najmniejszego modelu, który spełnia Twoje wymagania jakościowe. Jeśli to możliwe, buforuj powtórzone prompty. Minimalizuj długość system prompt i unikaj niepotrzebnego kontekstu. W przypadku prostych zadań klasyfikacji lub ekstrakcji, mniejsze modele, takie jak GPT-4o mini lub Gemini Flash, oferują znaczne oszczędności.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Wybierz model',
+    text: 'Wybierz model AI, który planujesz użyć, z rozwijanego menu pogrupowanego. Modele są zorganizowane według dostawcy.',
+  },
+  {
+    name: 'Wprowadź liczbę tokenów',
+    text: 'Wprowadź oczekiwaną liczbę tokenów wejściowych (Twój prompt) i tokenów wyjściowych (odpowiedź). Poniżej każdego pola pojawią się oszacowania słów.',
+  },
+  {
+    name: 'Ustaw liczbę żądań',
+    text: 'Użyj suwaka lub pola liczby, aby wprowadzić, ile połączeń API spodziewasz się. Całkowity koszt aktualizuje się w czasie rzeczywistym.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowToThing> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'DeveloperApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  inLanguage: 'pl',
+};
+
+const ui: LlmCostCalculatorUI = {
+  labelModel: 'Model LLM',
+  labelInputTokens: 'Tokeny Wejściowe',
+  labelOutputTokens: 'Tokeny Wyjściowe',
+  labelRequests: 'Liczba Żądań',
+  unitWords: 'słowa',
+  labelCostPerRequest: 'Koszt za Żądanie',
+  labelTotal: 'Szacunkowy Całkowity Koszt',
+  labelInput: 'Wejście',
+  labelOutput: 'Wyjście',
+};
+
+export const content: ToolLocaleContent<LlmCostCalculatorUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faqTitle: 'Często Zadawane Pytania',
+  faq: faqData,
+  bibliographyTitle: 'Referencje i Źródła Cen',
+  bibliography: [
+    {
+      name: 'Ceny API OpenAI',
+      url: 'https://openai.com/pricing',
+    },
+    {
+      name: 'Ceny API Anthropic',
+      url: 'https://www.anthropic.com/pricing',
+    },
+    {
+      name: 'Ceny Google AI Studio',
+      url: 'https://ai.google.dev/pricing',
+    },
+    {
+      name: 'Tokenizer OpenAI',
+      url: 'https://platform.openai.com/tokenizer',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'Zrozumienie cen API LLM',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Interfejsy API dużych modeli językowych pobierają opłaty na podstawie użycia tokenów, a nie czasu lub żądań. Każde połączenie API ma dwa koszty: <strong>koszt wejścia</strong> (przetwarzanie Twojego promptu) i <strong>koszt wyjścia</strong> (generowanie odpowiedzi). Zrozumienie tego podziału jest kluczowe do dokładnego oszacowania Twojego miesięcznego rachunku.',
+    },
+    {
+      type: 'title',
+      text: 'Tokeny wejściowe a tokeny wyjściowe',
+      level: 3,
+    },
+    {
+      type: 'grid',
+      columns: 2,
+    },
+    {
+      type: 'card',
+      title: 'Tokeny wejściowe',
+      html: '<p>Tokeny wejściowe reprezentują wszystko wysłane <strong>do</strong> modelu: Twój system prompt, historię konwersacji i komunikat użytkownika. Są tańsze, ponieważ model przetwarza je równolegle. Typowy system prompt 200 słów kosztuje około 267 tokenów wejściowych.</p>',
+    },
+    {
+      type: 'card',
+      title: 'Tokeny wyjściowe',
+      html: '<p>Tokeny wyjściowe są generowane jeden po drugim w sekwencji, co czyni je bardziej kosztownym obliczeniowo. Większość dostawców pobiera <strong>3-5 razy więcej</strong> za tokeny wyjściowe. Odpowiedź 300 słów generuje około 400 tokenów wyjściowych. Utrzymanie odpowiedzi zwięzłe to jedna z najskuteczniejszych strategii obniżania kosztów.</p>',
+    },
+    {
+      type: 'title',
+      text: 'Wybór właściwego modelu do Twojego budżetu',
+      level: 3,
+    },
+    {
+      type: 'tip',
+      html: 'Zacznij od zdolnego modelu średniej klasy, takiego jak <code>GPT-4o mini</code> lub <code>Gemini 1.5 Flash</code>, i uaktualnij tylko wtedy, gdy jakość spadnie. Różnica w kosztach między małym a dużym modelem może wynosić 10-100 razy.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Nie wszystkie zadania wymagają tej samej jakości modelu. Zadania klasyfikacji, ekstrakcji i streszczania często działają dobrze z mniejszymi, tańszymi modelami. Zarezerwuj duże modele graniczne, takie jak <code>claude-3-opus</code> lub <code>o1</code>, na złożone zadania rozumowania, gdzie jakość bezpośrednio wpływa na wyniki.',
+    },
+  ],
+};

package/src/tool/llmCostCalculator/i18n/pt.ts

@@ -0,0 +1,165 @@
+import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { LlmCostCalculatorUI } from '../ui';
+
+const slug = 'calculadora-custo-llm';
+const title = 'Calculadora de Custo LLM. Estimador de Preços de Modelos IA';
+const description =
+  'Ferramenta online gratuita para estimar o custo de chamar APIs LLM. Compare GPT-4o, Claude, Gemini, Llama e mais com preços reais de tokens por milhão.';
+
+const faqData = [
+  {
+    question: 'Como é calculado o custo da API LLM?',
+    answer:
+      'As APIs LLM cobram separadamente para tokens de entrada (seu prompt) e tokens de saída (a resposta). O custo total por solicitação é: (tokens de entrada × preço de entrada + tokens de saída × preço de saída) / 1.000.000. Multiplique pelo número de solicitações para obter o custo mensal total.',
+  },
+  {
+    question: 'O que são tokens e como se relacionam com palavras?',
+    answer:
+      'Um token é a unidade básica de texto que um modelo de linguagem processa. Em média, 1 token equivale a cerca de 0,75 palavras em inglês, então 1.000 tokens ≈ 750 palavras. Os preços são listados por milhão de tokens ($/1M), que é a unidade de preço padrão em todos os provedores.',
+  },
+  {
+    question: 'Por que os tokens de saída são mais caros que os de entrada?',
+    answer:
+      'Gerar texto (saída) requer que o modelo compute cada token sequencialmente, o que é computacionalmente mais intensivo do que ler a entrada. A maioria dos provedores cobra 3–5x mais para tokens de saída do que de entrada.',
+  },
+  {
+    question: 'Como posso reduzir meus custos de API LLM?',
+    answer:
+      'Use o menor modelo que atenda a seus requisitos de qualidade. Cache prompts repetidos quando possível. Minimize o comprimento do prompt do sistema e evite contexto desnecessário. Para tarefas simples de classificação ou extração, modelos menores como GPT-4o mini ou Gemini Flash oferecem economias significativas.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Selecione um modelo',
+    text: 'Escolha o modelo IA que você planeja usar no dropdown agrupado. Os modelos são organizados por provedor.',
+  },
+  {
+    name: 'Insira contagens de tokens',
+    text: 'Digite o número esperado de tokens de entrada (seu prompt) e tokens de saída (a resposta). Estimativas de palavras aparecem abaixo de cada campo.',
+  },
+  {
+    name: 'Defina o número de solicitações',
+    text: 'Use o slider ou entrada numérica para inserir quantas chamadas de API você espera. O custo total é atualizado em tempo real.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowToThing> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'DeveloperApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  inLanguage: 'pt',
+};
+
+const ui: LlmCostCalculatorUI = {
+  labelModel: 'Modelo LLM',
+  labelInputTokens: 'Tokens de Entrada',
+  labelOutputTokens: 'Tokens de Saída',
+  labelRequests: 'Número de Solicitações',
+  unitWords: 'palavras',
+  labelCostPerRequest: 'Custo por Solicitação',
+  labelTotal: 'Custo Total Estimado',
+  labelInput: 'Entrada',
+  labelOutput: 'Saída',
+};
+
+export const content: ToolLocaleContent<LlmCostCalculatorUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faqTitle: 'Perguntas Frequentes',
+  faq: faqData,
+  bibliographyTitle: 'Referências e Fontes de Preços',
+  bibliography: [
+    {
+      name: 'Preços de API OpenAI',
+      url: 'https://openai.com/pricing',
+    },
+    {
+      name: 'Preços de API Anthropic',
+      url: 'https://www.anthropic.com/pricing',
+    },
+    {
+      name: 'Preços Google AI Studio',
+      url: 'https://ai.google.dev/pricing',
+    },
+    {
+      name: 'Tokenizador OpenAI',
+      url: 'https://platform.openai.com/tokenizer',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'Entendendo preços de API LLM',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'As APIs de Modelo de Linguagem Grande cobram com base no uso de tokens, não em tempo ou solicitações. Cada chamada de API tem dois custos: o <strong>custo de entrada</strong> (processando seu prompt) e o <strong>custo de saída</strong> (gerando a resposta). Entender essa divisão é fundamental para estimar sua fatura mensal com precisão.',
+    },
+    {
+      type: 'title',
+      text: 'Tokens de entrada vs tokens de saída',
+      level: 3,
+    },
+    {
+      type: 'grid',
+      columns: 2,
+    },
+    {
+      type: 'card',
+      title: 'Tokens de entrada',
+      html: '<p>Os tokens de entrada representam tudo enviado <strong>para</strong> o modelo: seu prompt do sistema, histórico de conversa e mensagem do usuário. Eles são mais baratos porque o modelo os processa em paralelo. Um prompt de sistema típico de 200 palavras custa aproximadamente 267 tokens de entrada.</p>',
+    },
+    {
+      type: 'card',
+      title: 'Tokens de saída',
+      html: '<p>Os tokens de saída são gerados um por um em sequência, tornando-os computacionalmente mais caros. A maioria dos provedores cobra <strong>3–5× mais</strong> para tokens de saída. Uma resposta de 300 palavras gera aproximadamente 400 tokens de saída. Manter as respostas concisas é uma das estratégias mais eficazes de economia de custos.</p>',
+    },
+    {
+      type: 'title',
+      text: 'Escolhendo o modelo certo para seu orçamento',
+      level: 3,
+    },
+    {
+      type: 'tip',
+      html: 'Comece com um modelo de nível médio capaz como <code>GPT-4o mini</code> ou <code>Gemini 1.5 Flash</code> e atualize apenas se a qualidade for insuficiente. A diferença de custo entre um modelo pequeno e grande pode ser 10–100×.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Nem todas as tarefas requerem a mesma qualidade de modelo. Tarefas de classificação, extração e resumo geralmente funcionam bem com modelos menores e mais baratos. Reserve grandes modelos de fronteira como <code>claude-3-opus</code> ou <code>o1</code> para tarefas de raciocínio complexo onde a qualidade afeta diretamente os resultados.',
+    },
+  ],
+};

package/src/tool/llmCostCalculator/i18n/ru.ts

@@ -0,0 +1,165 @@
+import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { LlmCostCalculatorUI } from '../ui';
+
+const slug = 'kalkulyator-stoimosti-llm';
+const title = 'Калькулятор Стоимости LLM. Оценитель Цен AI Моделей';
+const description =
+  'Бесплатный онлайн инструмент для оценки стоимости вызовов API LLM. Сравните GPT-4o, Claude, Gemini, Llama и другие с реальными ценами токенов за миллион.';
+
+const faqData = [
+  {
+    question: 'Как рассчитывается стоимость API LLM?',
+    answer:
+      'API LLM взимают отдельную плату за входные токены (ваш промпт) и выходные токены (ответ). Общая стоимость за запрос: (входные токены × цена входа + выходные токены × цена выхода) / 1,000,000. Умножьте на количество запросов, чтобы получить общую ежемесячную стоимость.',
+  },
+  {
+    question: 'Что такое токены и как они соотносятся со словами?',
+    answer:
+      'Токен - это основная единица текста, которую обрабатывает языковая модель. В среднем 1 токен равен примерно 0,75 слова на английском, поэтому 1000 токенов ≈ 750 слов. Цены указаны за миллион токенов ($/1M), что является стандартной единицей ценообразования у всех провайдеров.',
+  },
+  {
+    question: 'Почему выходные токены дороже входных?',
+    answer:
+      'Генерирование текста (выход) требует, чтобы модель последовательно вычисляла каждый токен, что вычислительно более интенсивно, чем чтение входа. Большинство провайдеров взимают в 3–5 раз больше за выходные токены, чем за входные.',
+  },
+  {
+    question: 'Как я могу снизить свои расходы на API LLM?',
+    answer:
+      'Используйте самую маленькую модель, которая соответствует вашим требованиям к качеству. Кэшируйте повторяющиеся промпты, когда возможно. Минимизируйте длину системного промпта и избегайте ненужного контекста. Для простых задач классификации или извлечения меньшие модели, такие как GPT-4o mini или Gemini Flash, предлагают значительную экономию.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Выберите модель',
+    text: 'Выберите модель AI, которую вы планируете использовать, из сгруппированного выпадающего меню. Модели организованы по провайдерам.',
+  },
+  {
+    name: 'Введите количество токенов',
+    text: 'Введите ожидаемое количество входных токенов (ваш промпт) и выходных токенов (ответ). Оценки слов отображаются под каждым полем.',
+  },
+  {
+    name: 'Установите количество запросов',
+    text: 'Используйте ползунок или числовой ввод, чтобы указать, сколько вызовов API вы ожидаете. Общая стоимость обновляется в реальном времени.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowToThing> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'DeveloperApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  inLanguage: 'ru',
+};
+
+const ui: LlmCostCalculatorUI = {
+  labelModel: 'Модель LLM',
+  labelInputTokens: 'Входные Токены',
+  labelOutputTokens: 'Выходные Токены',
+  labelRequests: 'Количество Запросов',
+  unitWords: 'слова',
+  labelCostPerRequest: 'Стоимость за Запрос',
+  labelTotal: 'Предполагаемая Общая Стоимость',
+  labelInput: 'Вход',
+  labelOutput: 'Выход',
+};
+
+export const content: ToolLocaleContent<LlmCostCalculatorUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faqTitle: 'Часто Задаваемые Вопросы',
+  faq: faqData,
+  bibliographyTitle: 'Справочные Материалы и Источники Цен',
+  bibliography: [
+    {
+      name: 'Цены на OpenAI API',
+      url: 'https://openai.com/pricing',
+    },
+    {
+      name: 'Цены на Anthropic API',
+      url: 'https://www.anthropic.com/pricing',
+    },
+    {
+      name: 'Цены Google AI Studio',
+      url: 'https://ai.google.dev/pricing',
+    },
+    {
+      name: 'Токенизатор OpenAI',
+      url: 'https://platform.openai.com/tokenizer',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'Понимание ценообразования API LLM',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'API больших языковых моделей взимают плату на основе использования токенов, а не времени или количества запросов. Каждый вызов API имеет две стоимости: <strong>входная стоимость</strong> (обработка вашего промпта) и <strong>выходная стоимость</strong> (генерирование ответа). Понимание этого разделения критически важно для точной оценки вашего ежемесячного счета.',
+    },
+    {
+      type: 'title',
+      text: 'Входные токены vs выходные токены',
+      level: 3,
+    },
+    {
+      type: 'grid',
+      columns: 2,
+    },
+    {
+      type: 'card',
+      title: 'Входные токены',
+      html: '<p>Входные токены представляют все, что отправляется <strong>в</strong> модель: ваш системный промпт, историю беседы и сообщение пользователя. Они дешевле, потому что модель обрабатывает их параллельно. Типичный системный промпт из 200 слов стоит примерно 267 входных токенов.</p>',
+    },
+    {
+      type: 'card',
+      title: 'Выходные токены',
+      html: '<p>Выходные токены генерируются один за другим последовательно, делая их вычислительно более дорогостоящими. Большинство провайдеров взимают <strong>3–5× больше</strong> за выходные токены. Ответ из 300 слов генерирует примерно 400 выходных токенов. Сохранение ответов краткими - одна из наиболее эффективных стратегий экономии затрат.</p>',
+    },
+    {
+      type: 'title',
+      text: 'Выбор подходящей модели для вашего бюджета',
+      level: 3,
+    },
+    {
+      type: 'tip',
+      html: 'Начните с способной модели среднего уровня, такой как <code>GPT-4o mini</code> или <code>Gemini 1.5 Flash</code>, и обновляйте, только если качество недостаточно. Разница в стоимости между маленькой и большой моделью может быть 10–100×.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Не все задачи требуют одинакового качества модели. Задачи классификации, извлечения и суммирования часто работают хорошо с меньшими, более дешёвыми моделями. Оставляйте большие граничные модели, такие как <code>claude-3-opus</code> или <code>o1</code>, для сложных задач рассуждения, где качество напрямую влияет на результаты.',
+    },
+  ],
+};