@jjlmoya/utils-developer 1.2.0

package/src/tool/llmCostCalculator/i18n/en.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 = 'llm-cost-calculator';
+const title = 'LLM Cost Calculator. AI Model Pricing Estimator';
+const description =
+  'Free online tool to estimate the cost of calling LLM APIs. Compare GPT-4o, Claude, Gemini, Llama and more with real token prices per million tokens.';
+
+const faqData = [
+  {
+    question: 'How is the LLM API cost calculated?',
+    answer:
+      'LLM APIs charge separately for input tokens (the prompt) and output tokens (the response). The total cost per request is: (input tokens × input price + output tokens × output price) / 1,000,000. Multiply by the number of requests to get the total monthly cost.',
+  },
+  {
+    question: 'What are tokens and how do they relate to words?',
+    answer:
+      'A token is the basic unit of text that a language model processes. On average, 1 token equals about 0.75 words in English, so 1,000 tokens ≈ 750 words. Prices are listed per million tokens ($/1M), which is the standard pricing unit across providers.',
+  },
+  {
+    question: 'Why are output tokens more expensive than input tokens?',
+    answer:
+      'Generating text (output) requires the model to compute each token sequentially, which is computationally more intensive than reading the input. Most providers charge 3–5x more for output tokens than input tokens.',
+  },
+  {
+    question: 'How can I reduce my LLM API costs?',
+    answer:
+      'Use the smallest model that meets your quality requirements. Cache repeated prompts when possible. Minimize system prompt length and avoid unnecessary context. For simple classification or extraction tasks, smaller models like GPT-4o mini or Gemini Flash offer significant savings.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Select a model',
+    text: 'Choose the AI model you plan to use from the grouped dropdown. Models are organized by provider.',
+  },
+  {
+    name: 'Enter token counts',
+    text: 'Enter the expected number of input tokens (your prompt) and output tokens (the response). Word estimates appear below each field.',
+  },
+  {
+    name: 'Set the number of requests',
+    text: 'Use the slider or number input to enter how many API calls you expect. The total cost updates in real time.',
+  },
+];
+
+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: 'en',
+};
+
+const ui: LlmCostCalculatorUI = {
+  labelModel: 'LLM Model',
+  labelInputTokens: 'Input Tokens',
+  labelOutputTokens: 'Output Tokens',
+  labelRequests: 'Number of Requests',
+  unitWords: 'words',
+  labelCostPerRequest: 'Cost per Request',
+  labelTotal: 'Estimated Total Cost',
+  labelInput: 'Input',
+  labelOutput: 'Output',
+};
+
+export const content: ToolLocaleContent<LlmCostCalculatorUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faqTitle: 'Frequently Asked Questions',
+  faq: faqData,
+  bibliographyTitle: 'References and Pricing Sources',
+  bibliography: [
+    {
+      name: 'OpenAI API Pricing',
+      url: 'https://openai.com/pricing',
+    },
+    {
+      name: 'Anthropic API Pricing',
+      url: 'https://www.anthropic.com/pricing',
+    },
+    {
+      name: 'Google AI Studio Pricing',
+      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: 'Understanding LLM API pricing',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Large Language Model APIs charge based on token usage, not time or requests. Every API call has two costs: the <strong>input cost</strong> (processing your prompt) and the <strong>output cost</strong> (generating the response). Understanding this split is key to estimating your monthly bill accurately.',
+    },
+    {
+      type: 'title',
+      text: 'Input tokens vs output tokens',
+      level: 3,
+    },
+    {
+      type: 'grid',
+      columns: 2,
+    },
+    {
+      type: 'card',
+      title: 'Input tokens',
+      html: '<p>Input tokens represent everything sent <strong>to</strong> the model: your system prompt, conversation history, and user message. They are cheaper because the model processes them in parallel. A typical system prompt of 200 words costs roughly 267 input tokens.</p>',
+    },
+    {
+      type: 'card',
+      title: 'Output tokens',
+      html: '<p>Output tokens are generated one by one in sequence, making them more computationally expensive. Most providers charge <strong>3–5× more</strong> for output tokens. A 300-word response generates roughly 400 output tokens. Keeping responses concise is one of the most effective cost-saving strategies.</p>',
+    },
+    {
+      type: 'title',
+      text: 'Choosing the right model for your budget',
+      level: 3,
+    },
+    {
+      type: 'tip',
+      html: 'Start with a capable mid-tier model like <code>GPT-4o mini</code> or <code>Gemini 1.5 Flash</code> and only upgrade if quality falls short. The cost difference between a small and large model can be 10–100×.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Not all tasks require the same model quality. Classification, extraction, and summarization tasks often perform well with smaller, cheaper models. Reserve large frontier models like <code>claude-3-opus</code> or <code>o1</code> for complex reasoning tasks where quality directly affects outcomes.',
+    },
+  ],
+};

package/src/tool/llmCostCalculator/i18n/es.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 = 'llm-cost-calculator';
+const title = 'Calculadora de Costes de LLMs. Estimador de Precios de APIs de IA';
+const description =
+  'Herramienta online gratuita para estimar el coste de llamadas a APIs de modelos de lenguaje. Compara GPT-4o, Claude, Gemini, Llama y más con precios reales por millón de tokens.';
+
+const faqData = [
+  {
+    question: '¿Cómo se calcula el coste de una API de LLM?',
+    answer:
+      'Las APIs de LLM cobran de forma separada por los tokens de entrada (el prompt) y los tokens de salida (la respuesta). El coste total por petición es: (tokens entrada × precio entrada + tokens salida × precio salida) / 1.000.000. Multiplica por el número de peticiones para obtener el coste mensual total.',
+  },
+  {
+    question: '¿Qué son los tokens y cómo se relacionan con las palabras?',
+    answer:
+      'Un token es la unidad básica de texto que procesa un modelo de lenguaje. En promedio, 1 token equivale a aproximadamente 0,75 palabras en inglés, es decir, 1.000 tokens ≈ 750 palabras. Los precios se indican por millón de tokens ($/1M), que es la unidad estándar en todos los proveedores.',
+  },
+  {
+    question: '¿Por qué los tokens de salida son más caros que los de entrada?',
+    answer:
+      'Generar texto (salida) requiere que el modelo calcule cada token de forma secuencial, lo cual es computacionalmente más costoso que leer la entrada. La mayoría de los proveedores cobran entre 3 y 5 veces más por los tokens de salida que por los de entrada.',
+  },
+  {
+    question: '¿Cómo puedo reducir los costes de la API de un LLM?',
+    answer:
+      'Usa el modelo más pequeño que cumpla tus requisitos de calidad. Cachea los prompts repetidos cuando sea posible. Minimiza la longitud del prompt de sistema y evita contexto innecesario. Para tareas simples de clasificación o extracción, modelos más pequeños como GPT-4o mini o Gemini Flash ofrecen un ahorro significativo.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Selecciona un modelo',
+    text: 'Elige el modelo de IA que planeas usar en el desplegable agrupado. Los modelos están organizados por proveedor.',
+  },
+  {
+    name: 'Introduce el número de tokens',
+    text: 'Introduce el número esperado de tokens de entrada (tu prompt) y de salida (la respuesta). Debajo de cada campo aparece una estimación en palabras.',
+  },
+  {
+    name: 'Ajusta el número de peticiones',
+    text: 'Usa el deslizador o el campo numérico para indicar cuántas llamadas a la API esperas. El coste total se actualiza en tiempo 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: 'es',
+};
+
+const ui: LlmCostCalculatorUI = {
+  labelModel: 'Modelo LLM',
+  labelInputTokens: 'Tokens Entrada',
+  labelOutputTokens: 'Tokens Salida',
+  labelRequests: 'Número de Peticiones',
+  unitWords: 'palabras',
+  labelCostPerRequest: 'Coste por Petición',
+  labelTotal: 'Coste Total Estimado',
+  labelInput: 'Input',
+  labelOutput: 'Output',
+};
+
+export const content: ToolLocaleContent<LlmCostCalculatorUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faqTitle: 'Preguntas Frecuentes',
+  faq: faqData,
+  bibliographyTitle: 'Referencias y Fuentes de Precios',
+  bibliography: [
+    {
+      name: 'Precios de la API de OpenAI',
+      url: 'https://openai.com/pricing',
+    },
+    {
+      name: 'Precios de la API de Anthropic',
+      url: 'https://www.anthropic.com/pricing',
+    },
+    {
+      name: 'Precios de Google AI Studio',
+      url: 'https://ai.google.dev/pricing',
+    },
+    {
+      name: 'Tokenizador de OpenAI',
+      url: 'https://platform.openai.com/tokenizer',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'Cómo funciona el precio de las APIs de LLM',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Las APIs de modelos de lenguaje cobran en función del uso de tokens, no por tiempo ni por petición. Cada llamada tiene dos costes: el <strong>coste de entrada</strong> (procesar tu prompt) y el <strong>coste de salida</strong> (generar la respuesta). Entender esta diferencia es clave para estimar con precisión tu factura mensual.',
+    },
+    {
+      type: 'title',
+      text: 'Tokens de entrada frente a tokens de salida',
+      level: 3,
+    },
+    {
+      type: 'grid',
+      columns: 2,
+    },
+    {
+      type: 'card',
+      title: 'Tokens de entrada',
+      html: '<p>Los tokens de entrada representan todo lo que se envía <strong>al</strong> modelo: tu prompt de sistema, el historial de conversación y el mensaje del usuario. Son más baratos porque el modelo los procesa en paralelo. Un prompt de sistema típico de 200 palabras genera aproximadamente 267 tokens de entrada.</p>',
+    },
+    {
+      type: 'card',
+      title: 'Tokens de salida',
+      html: '<p>Los tokens de salida se generan uno a uno de forma secuencial, lo que los hace computacionalmente más costosos. La mayoría de los proveedores cobran <strong>entre 3 y 5 veces más</strong> por los tokens de salida. Una respuesta de 300 palabras genera aproximadamente 400 tokens de salida. Mantener las respuestas concisas es una de las estrategias de ahorro más efectivas.</p>',
+    },
+    {
+      type: 'title',
+      text: 'Elegir el modelo adecuado para tu presupuesto',
+      level: 3,
+    },
+    {
+      type: 'tip',
+      html: 'Empieza con un modelo de gama media como <code>GPT-4o mini</code> o <code>Gemini 1.5 Flash</code> y solo escala si la calidad no es suficiente. La diferencia de coste entre un modelo pequeño y uno grande puede ser de 10 a 100 veces.',
+    },
+    {
+      type: 'paragraph',
+      html: 'No todas las tareas requieren el mismo nivel de modelo. Las tareas de clasificación, extracción y resumen suelen funcionar bien con modelos más pequeños y económicos. Reserva los modelos más grandes como <code>claude-3-opus</code> o <code>o1</code> para razonamientos complejos donde la calidad afecta directamente al resultado.',
+    },
+  ],
+};

package/src/tool/llmCostCalculator/i18n/fr.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 = 'llm-cost-calculator';
+const title = 'Calculateur de Coûts LLM. Estimateur de Prix des APIs IA';
+const description =
+  'Outil en ligne gratuit pour estimer le coût des appels aux APIs de modèles de langage. Comparez GPT-4o, Claude, Gemini, Llama et plus avec les vrais prix par million de tokens.';
+
+const faqData = [
+  {
+    question: "Comment le coût d'une API LLM est-il calculé ?",
+    answer:
+      "Les APIs LLM facturent séparément les tokens d'entrée (le prompt) et les tokens de sortie (la réponse). Le coût total par requête est : (tokens entrée × prix entrée + tokens sortie × prix sortie) / 1 000 000. Multipliez par le nombre de requêtes pour obtenir le coût mensuel total.",
+  },
+  {
+    question: 'Que sont les tokens et comment se rapportent-ils aux mots ?',
+    answer:
+      "Un token est l'unité de base de texte qu'un modèle de langage traite. En moyenne, 1 token équivaut à environ 0,75 mot en anglais, soit 1 000 tokens ≈ 750 mots. Les prix sont indiqués par million de tokens ($/1M), qui est l'unité tarifaire standard chez tous les fournisseurs.",
+  },
+  {
+    question: "Pourquoi les tokens de sortie sont-ils plus chers que les tokens d'entrée ?",
+    answer:
+      "Générer du texte (sortie) oblige le modèle à calculer chaque token séquentiellement, ce qui est plus coûteux en calcul que de lire l'entrée. La plupart des fournisseurs facturent 3 à 5 fois plus pour les tokens de sortie que pour les tokens d'entrée.",
+  },
+  {
+    question: 'Comment réduire les coûts de mon API LLM ?',
+    answer:
+      "Utilisez le modèle le plus petit qui répond à vos exigences de qualité. Mettez en cache les prompts répétés si possible. Minimisez la longueur du prompt système et évitez le contexte inutile. Pour les tâches simples de classification ou d'extraction, des modèles plus petits comme GPT-4o mini ou Gemini Flash offrent des économies significatives.",
+  },
+];
+
+const howToData = [
+  {
+    name: 'Sélectionner un modèle',
+    text: "Choisissez le modèle IA que vous prévoyez d'utiliser dans la liste déroulante groupée. Les modèles sont organisés par fournisseur.",
+  },
+  {
+    name: 'Saisir le nombre de tokens',
+    text: "Entrez le nombre attendu de tokens d'entrée (votre prompt) et de sortie (la réponse). Une estimation en mots apparaît sous chaque champ.",
+  },
+  {
+    name: 'Définir le nombre de requêtes',
+    text: "Utilisez le curseur ou le champ numérique pour indiquer combien d'appels API vous prévoyez. Le coût total se met à jour en temps réel.",
+  },
+];
+
+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: 'fr',
+};
+
+const ui: LlmCostCalculatorUI = {
+  labelModel: 'Modèle LLM',
+  labelInputTokens: "Tokens d'entrée",
+  labelOutputTokens: 'Tokens de sortie',
+  labelRequests: 'Nombre de requêtes',
+  unitWords: 'mots',
+  labelCostPerRequest: 'Coût par requête',
+  labelTotal: 'Coût total estimé',
+  labelInput: 'Input',
+  labelOutput: 'Output',
+};
+
+export const content: ToolLocaleContent<LlmCostCalculatorUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faqTitle: 'Questions fréquentes',
+  faq: faqData,
+  bibliographyTitle: 'Références et Sources de Prix',
+  bibliography: [
+    {
+      name: "Tarification de l'API OpenAI",
+      url: 'https://openai.com/pricing',
+    },
+    {
+      name: "Tarification de l'API Anthropic",
+      url: 'https://www.anthropic.com/pricing',
+    },
+    {
+      name: 'Tarification Google AI Studio',
+      url: 'https://ai.google.dev/pricing',
+    },
+    {
+      name: 'Tokeniseur OpenAI',
+      url: 'https://platform.openai.com/tokenizer',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'Comprendre la tarification des APIs LLM',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: "Les APIs de modèles de langage facturent en fonction de l'utilisation des tokens, et non du temps ou des requêtes. Chaque appel a deux coûts : le <strong>coût d'entrée</strong> (traitement de votre prompt) et le <strong>coût de sortie</strong> (génération de la réponse). Comprendre cette distinction est essentiel pour estimer avec précision votre facture mensuelle.",
+    },
+    {
+      type: 'title',
+      text: "Tokens d'entrée et tokens de sortie",
+      level: 3,
+    },
+    {
+      type: 'grid',
+      columns: 2,
+    },
+    {
+      type: 'card',
+      title: "Tokens d'entrée",
+      html: "<p>Les tokens d'entrée représentent tout ce qui est envoyé <strong>au</strong> modèle : votre prompt système, l'historique de la conversation et le message de l'utilisateur. Ils sont moins chers car le modèle les traite en parallèle. Un prompt système typique de 200 mots génère environ 267 tokens d'entrée.</p>",
+    },
+    {
+      type: 'card',
+      title: 'Tokens de sortie',
+      html: '<p>Les tokens de sortie sont générés un par un séquentiellement, ce qui les rend plus coûteux en calcul. La plupart des fournisseurs facturent <strong>3 à 5 fois plus</strong> pour les tokens de sortie. Une réponse de 300 mots génère environ 400 tokens de sortie. Garder les réponses concises est une des stratégies d\'économie les plus efficaces.</p>',
+    },
+    {
+      type: 'title',
+      text: 'Choisir le bon modèle pour votre budget',
+      level: 3,
+    },
+    {
+      type: 'tip',
+      html: 'Commencez avec un modèle de milieu de gamme comme <code>GPT-4o mini</code> ou <code>Gemini 1.5 Flash</code> et ne montez en gamme que si la qualité est insuffisante. La différence de coût entre un petit et un grand modèle peut être de 10 à 100 fois.',
+    },
+    {
+      type: 'paragraph',
+      html: "Toutes les tâches ne nécessitent pas le même niveau de modèle. Les tâches de classification, d'extraction et de résumé fonctionnent souvent bien avec des modèles plus petits et moins chers. Réservez les grands modèles comme <code>claude-3-opus</code> ou <code>o1</code> pour les raisonnements complexes où la qualité impacte directement les résultats.",
+    },
+  ],
+};

package/src/tool/llmCostCalculator/index.ts

@@ -0,0 +1,34 @@
+import type { DeveloperToolEntry, ToolLocaleContent, ToolDefinition } from '../../types';
+import LlmCostCalculatorComponent from './component.astro';
+import LlmCostCalculatorSEO from './seo.astro';
+import LlmCostCalculatorBibliography from './bibliography.astro';
+
+import type { LlmCostCalculatorUI } from './ui';
+
+export type LlmCostCalculatorLocaleContent = ToolLocaleContent<LlmCostCalculatorUI>;
+
+import { content as es } from './i18n/es';
+import { content as en } from './i18n/en';
+import { content as fr } from './i18n/fr';
+
+export const llmCostCalculator: DeveloperToolEntry<LlmCostCalculatorUI> = {
+  id: 'llm-cost-calculator',
+  icons: {
+    bg: 'mdi:currency-usd',
+    fg: 'mdi:robot-outline',
+  },
+  i18n: {
+    es: async () => es,
+    en: async () => en,
+    fr: async () => fr,
+  },
+};
+
+export { LlmCostCalculatorComponent, LlmCostCalculatorSEO, LlmCostCalculatorBibliography };
+
+export const LLM_COST_CALCULATOR_TOOL: ToolDefinition = {
+  entry: llmCostCalculator,
+  Component: LlmCostCalculatorComponent,
+  SEOComponent: LlmCostCalculatorSEO,
+  BibliographyComponent: LlmCostCalculatorBibliography,
+};

package/src/tool/llmCostCalculator/seo.astro

@@ -0,0 +1,14 @@
+---
+import { SEORenderer } from '@jjlmoya/utils-shared';
+import { llmCostCalculator } from './index';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'es' } = Astro.props;
+const content = await llmCostCalculator.i18n[locale]?.();
+---
+
+{content && <SEORenderer content={{ locale, sections: content.seo }} />}

package/src/tool/llmCostCalculator/ui.ts

@@ -0,0 +1,11 @@
+export interface LlmCostCalculatorUI extends Record<string, string> {
+  labelModel: string;
+  labelInputTokens: string;
+  labelOutputTokens: string;
+  labelRequests: string;
+  unitWords: string;
+  labelCostPerRequest: string;
+  labelTotal: string;
+  labelInput: string;
+  labelOutput: string;
+}