La fundamentación con
La fundamentación con
- Aumenta la exactitud fáctica: Reduce las alucinaciones del modelo basando las respuestas en la base de datos de Google de más de 250 millones de lugares y empresas del mundo real.
- Accede a información en tiempo real: Responde preguntas con datos en tiempo real, como el horario de atención actual y el estado en tiempo real de las estaciones de carga de VE.
- Proporciona fuentes: Genera confianza en los usuarios mostrando fuentes y vínculos de lugares de
Google Maps directamente junto a las afirmaciones basadas en la ubicación del modelo.
Modelos compatibles
gemini-4-argongemini-3.8-flash(y los modelos anterioresgemini-3.7-flash,gemini-3.6-flashygemini-3.5-flash)gemini-3.5-flash-lite(y la versión anteriorgemini-3.1-flash-lite)
Los modelos gemini-3.1-pro-preview y Gemini 2.5 de uso general (que
dejaron de estar disponibles) también admiten esta capacidad.
Lenguajes compatibles
Consulta los idiomas admitidos para los modelos de Gemini.
Fundamenta el modelo con Google Maps
|
Haz clic en tu proveedor de Gemini API para ver el contenido y el código específicos del proveedor en esta página. |
Cuando crees la instancia GenerativeModel, proporciona GoogleMaps como un tool
que el modelo pueda usar para generar su respuesta.
Swift
import CoreLocation
import FirebaseAILogic
// Initialize the Gemini Developer API backend service.
let ai = FirebaseAI.firebaseAI(backend: .googleAI())
// Example: Coordinates for New York City
let latAndLong = CLLocationCoordinate2D(latitude: 40.7128, longitude: -74.0060)
// (Optional) Define a RetrievalConfig to configure the Grounding with Google Maps tool.
// You can optionally provide a location's coordinates and/or a language code
// for more relevant and personalized Google Maps results.
let retrievalConfig = RetrievalConfig(
location: latAndLong,
// Example: Language code for English (US).
languageCode: "en-US"
)
// Wrap the RetrievalConfig inside a ToolConfig.
let toolConfig = ToolConfig(retrievalConfig: retrievalConfig)
// Create a `GenerativeModel` instance with a model that supports your use case.
let model = ai.generativeModel(
modelName: "GEMINI_MODEL_NAME",
// Provide Google Maps as a tool that the model can use to generate its response.
tools: [.googleMaps()],
// Add the configuration for the Grounding with Google Maps tool
// (if this optional config was defined above).
toolConfig: toolConfig
)
let response = try await model.generateContent("restaurants near me?")
print(response.text ?? "No text in response.")
// Make sure to comply with the "Grounding with Google Maps " usage requirements,
// which includes how you meet service usage requirements
Kotlin
// (Optional) Define a RetrievalConfig to configure the Grounding with Google Maps tool.
// You can optionally provide a location's coordinates and/or a language code
// for more relevant and personalized Google Maps results.
val retrievalConfig = RetrievalConfig(
// Example: Coordinates for New York City
latLng = LatLng(latitude = 40.7128, longitude = -74.0060),
// Example: Language code for English (US)
languageCode = "en-US"
)
// Wrap the RetrievalConfig inside a ToolConfig.
val toolConfig = ToolConfig(
retrievalConfig = retrievalConfig
)
// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports your use case.
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
modelName = "GEMINI_MODEL_NAME",
// Add the configuration for the Grounding with Google Maps tool
// (if this optional config was defined above).
toolConfig = toolConfig,
// Provide Google Maps as a tool that the model can use to generate its response.
tools = listOf(Tool.googleMaps())
)
val response = model.generateContent("restaurants near me?")
print(response.text)
// Make sure to comply with the "Grounding with Google Maps " usage requirements,
// which includes how you meet service usage requirements
Java
// (Optional) Define a ToolConfig to configure the Grounding with Google Maps tool.
// You can optionally provide a location's coordinates and/or a language code
// for more relevant and personalized Google Maps results.
ToolConfig toolConfig = new ToolConfig(
null,
new RetrievalConfig(
// Example: Coordinates for New York City.
new LatLng(40.7128, -74.0060),
// Example: Language code for English (US).
"en-US"
)
);
// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports your use case.
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
.generativeModel("GEMINI_MODEL_NAME",
null,
null,
// Provide Google Maps as a tool that the model can use to generate its response.
List.of(Tool.googleMaps()),
// Add the configuration for the Grounding with Google Maps tool
// (if this optional config was defined above).
toolConfig);
// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs.
GenerativeModelFutures model = GenerativeModelFutures.from(ai);
ListenableFuture response = model.generateContent("restaurants near me?");
Futures.addCallback(response, new FutureCallback() {
@Override
public void onSuccess(GenerateContentResponse result) {
String resultText = result.getText();
System.out.println(resultText);
}
@Override
public void onFailure(Throwable t) {
t.printStackTrace();
}
}, executor);
// Make sure to comply with the "Grounding with Google Maps " usage requirements,
// which includes how you meet service usage requirements
Web
import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai";
// TODO(developer): Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
// ...
};
// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);
// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });
// (Optional) Define a toolConfig to configure the Grounding with Google Maps tool.
// You can optionally provide a location's coordinates and/or a language code
// for more relevant and personalized Google Maps results.
const toolConfig = {
retrievalConfig: {
// Example: Coordinates for New York City
latLng: {
latitude: 40.7128,
longitude: -74.0060
},
// Example: Language code for English (US)
languageCode: 'en-US'
}
};
// Create a `GenerativeModel` instance with a model that supports your use case
const model = getGenerativeModel(
ai,
{
model: "GEMINI_MODEL_NAME",
// Provide Google Maps as a tool that the model can use to generate its response.
tools: [ { googleMaps: {} } ],
// Add the configuration for the Grounding with Google Maps tool
// (if this optional config was defined above).
toolConfig
}
);
const result = await model.generateContent("restaurants near me?");
console.log(result.response.text());
// Make sure to comply with the "Grounding with Google Maps " usage requirements,
// which includes how you meet service usage requirements
Dart
import 'package:firebase_core/firebase_core.dart';
import 'package:firebase_ai/firebase_ai.dart';
import 'firebase_options.dart';
// Initialize FirebaseApp.
await Firebase.initializeApp(
options: DefaultFirebaseOptions.currentPlatform,
);
// (Optional) Define a ToolConfig to configure the Grounding with Google Maps tool.
// You can optionally provide a location's coordinates and/or a language code
// for more relevant and personalized Google Maps results.
final toolConfig = ToolConfig(
retrievalConfig: RetrievalConfig(
// Example: Coordinates for New York City.
latLng: LatLng(latitude: 40.712728, longitude: -74.006015),
// Example: Language code for English (US).
languageCode: 'en-US',
),
);
// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports your use case.
final model = FirebaseAI.googleAI().generativeModel(
model: 'GEMINI_MODEL_NAME',
// Provide Google Maps as a tool that the model can use to generate its response.
tools: [
Tool.googleMaps(),
],
// Add the configuration for the Grounding with Google Maps tool
// (if this optional config was defined above).
toolConfig: toolConfig,
);
final response = await model.generateContent([Content.text("restaurants near me?")]);
print(response.text);
// Make sure to comply with the "Grounding with Google Maps " usage requirements,
// which includes how you meet service usage requirements
Unity
using Firebase;
using Firebase.AI;
// Initialize the Gemini Developer API backend service.
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());
// Example: Coordinates for New York City
var latLng = new LatLng(40.7128, -74.0060);
// (Optional) Define a RetrievalConfig to configure the Grounding with Google Maps tool.
// You can optionally provide a location's coordinates and/or a language code
// for more relevant and personalized Google Maps results.
var retrievalConfig = new RetrievalConfig(latLng, languageCode: "en");
// Wrap the RetrievalConfig inside a ToolConfig.
var toolConfig = new ToolConfig(retrievalConfig: retrievalConfig);
// Create a `GenerativeModel` instance with a model that supports your use case.
var model = ai.GetGenerativeModel(
modelName: "GEMINI_MODEL_NAME",
// Provide Google Maps as a tool that the model can use to generate its response.
tools: new[] { new Tool(new GoogleMaps()) },
// Add the configuration for the Grounding with Google Maps tool
// (if this optional config was defined above).
toolConfig: toolConfig
);
var response = await model.GenerateContentAsync("restaurants near me?");
UnityEngine.Debug.Log(response.Text ?? "No text in response.");
// Make sure to comply with the "Grounding with Google Maps " usage requirements,
// which includes how you meet service usage requirements
Aprende a elegir un modelo adecuada para tu caso de uso y app.
Prácticas recomendadas y sugerencias para mejorar los resultados
En esta sección, se describen algunas prácticas recomendadas generales para usar la fundamentación con
Prácticas recomendadas generales
Proporciona la herramienta solo cuando sea necesario: Para optimizar el rendimiento y el costo, proporciona al modelo acceso a la herramienta de Fundamentación con
Google Maps solo cuando el caso de uso tenga un contexto geográfico claro.Proporciona la ubicación del usuario: Para obtener las respuestas más relevantes y personalizadas (y cuando se conozca la ubicación del usuario), incluye la ubicación del usuario (con la latitud y la longitud a través de
latLng) en la configuración de la herramienta de fundamentación conGoogle Maps .Informa a los usuarios finales: Informa con claridad a tus usuarios finales que se usan los datos de
Google Maps para responder sus consultas. Proporcionar a los usuarios finales las fuentes deGoogle Maps es un requisito de uso del servicio para la herramienta de Fundamentación conGoogle Maps .
Usa propiedades de lugares en las instrucciones
En esta sección, se enumeran las propiedades de lugar que se usan para describir ubicaciones
y que usa la fundamentación con
Propiedades de Place de muestra
En esta lista, se proporciona una muestra ordenada alfabéticamente de las propiedades sobre lugares que tu modelo puede usar para generar respuestas.
- Dirección
- Retiros en la puerta
- Tarjeta de débito
- Distancia
- Estacionamiento gratuito
- Música en vivo
- Menú para niños
- Horario de apertura
- Opciones de pago (como efectivo o tarjeta de crédito)
- Respuesta sobre el lugar
- Aptos para mascotas
- Ofrece cervezas
- Ofrece comida vegetariana
- Con acceso para personas en silla de ruedas
- Wi-Fi
Las respuestas de lugares son una respuesta de la fundamentación con
Ejemplos de instrucciones que usan propiedades de lugares
En los siguientes ejemplos, se usan
propiedades de lugares
en instrucciones sobre diferentes tipos de lugares. La fundamentación con
Planifica una cena familiar: Determina si un restaurante es adecuado para una familia y si ofrece un servicio conveniente.
- Instrucción de ejemplo: ¿"The Italian Place" es un buen lugar para niños y ofrece comida para llevar? ¿Cuál es su calificación?
Verificar la accesibilidad para un amigo: Determina si la ubicación cumple con necesidades de accesibilidad específicas.
- Instrucción de ejemplo: Necesito un restaurante que tenga una entrada accesible para personas en silla de ruedas.
Encontrar un lugar para comer un bocadillo nocturno: Busca un establecimiento abierto que sirva una comida específica durante un horario determinado.
- Instrucción de ejemplo: ¿Está abierto "Burger Joint" ahora? ¿Sirven cena? ¿Cuál es su horario de atención los viernes?
Reunirse con un cliente para tomar un café: Evalúa la idoneidad de una cafetería para una reunión de negocios en función de las comodidades, las ofertas y las opciones de pago.
- Instrucción de ejemplo: ¿"Café Central" tiene Wi-Fi? ¿Sirven café? ¿Cuál es su nivel de precios y si aceptan tarjetas de crédito?
Ten en cuenta que la información de los resultados fundamentados de
Cómo funciona la fundamentación con Google Maps
Cuando proporcionas al modelo la herramienta GoogleMaps, este controla todo el flujo de trabajo de búsqueda, procesamiento y cita de información de forma automática.
Este es el flujo de trabajo del modelo:
Recibe la instrucción: Tu app envía una instrucción al modelo de Gemini con la herramienta
GoogleMapshabilitada.Analiza la instrucción: El modelo analiza la instrucción y determina si
Google Maps puede mejorar su respuesta, por ejemplo, si la instrucción contiene contexto geográfico (como "cafeterías cerca de mí", "museos en San Francisco").Invoca la herramienta: El modelo, que reconoce la intención geográfica, invoca la herramienta de fundamentación con
Google Maps .Envía consultas a
Google Maps : El servicio de fundamentación conGoogle Maps consulta aGoogle Maps para obtener información relevante (por ejemplo, lugares, opiniones, fotos, direcciones y horarios de atención).De manera opcional, puedes incluir la latitud y la longitud en la configuración de la herramienta (o incluso directamente en la instrucción) para obtener resultados de
Google Maps más relevantes y personalizados. La herramienta es de búsqueda textual y se comporta de manera similar a la búsqueda enGoogle Maps , ya que las búsquedas locales ("cerca de mí") usarán las coordenadas, mientras que es poco probable que las búsquedas específicas o no locales se vean influenciadas por la ubicación explícita.Procesa los resultados de
Google Maps : El modelo procesa los resultados deGoogle Maps y formula una respuesta a la instrucción original.Devuelve un resultado fundamentado de
Google Maps : El modelo devuelve una respuesta final fácil de usar que se fundamenta en los resultados deGoogle Maps . La respuesta incluye los siguientes elementos:- La respuesta de texto del modelo.
- Un objeto
groundingMetadatacon los resultados y las fuentes deGoogle Maps .
Ten en cuenta que proporcionar groundingMetadata y, por lo tanto,
no es un resultado fundamentado de
Comprende el resultado fundamentado
Si el modelo fundamenta su respuesta en los resultados de groundingMetadata que contiene datos estructurados que son
esenciales para verificar las afirmaciones y crear una experiencia de fuente enriquecida en tu
aplicación.
El objeto groundingMetadata en un resultado fundamentado de
groundingChunks: Es un array de objetos que contiene las fuentes demaps(uri,placeIdytitle).groundingSupports: Es un array de fragmentos para conectar la respuesta del modelotextcon las fuentes engroundingChunks. Cada fragmento vincula un textosegment(definido porstartIndexyendIndex) a uno o másgroundingChunkIndices. Este campo te ayuda a crear vínculos de fuentes intercalados. Obtén información para cumplir con los requisitos de uso del servicio más adelante en esta página.
A continuación, se muestra un ejemplo de respuesta que incluye un objeto groundingMetadata:
{
"candidates": [
{
"content": {
"parts": [
{
"text": "CanteenM is an American restaurant with..."
}
],
"role": "model"
},
"groundingMetadata": {
"groundingChunks": [
{
"maps": {
"uri": "https://maps.google.com/?cid=13100894621228039586",
"title": "Heaven on 7th Marketplace",
"placeId": "places/ChIJ0-zA1vBZwokRon0fGj-6z7U"
}
}
],
"groundingSupports": [
{
"segment": {
"startIndex": 0,
"endIndex": 79,
"text": "CanteenM is an American restaurant with a 4.6-star rating and is open 24 hours."
},
"groundingChunkIndices": [0]
}
]
}
}
]
}
Requisitos de uso del servicio
En esta sección, se describen los requisitos de uso del servicio para la fundamentación con
Informa a los usuarios sobre las fuentes de Google Maps
Con cada groundingChunks que respaldan cada respuesta. También se devuelven los siguientes metadatos:
- URI de origen
- título
- ID
En tu app, cuando presentes resultados de la fundamentación con
Las fuentes de
Google Maps deben seguir inmediatamente al contenido generado que respaldan. Este contenido generado también se conoce como Resultado fundamentado deGoogle Maps .Las fuentes de
Google Maps deben poder verse en una sola interacción del usuario.
A continuación, se muestra cómo obtener valores para mostrar fuentes del
resultado fundamentado de
Swift
// ...
// Get the model's response
let text = response.text
// Get the grounding metadata
if let candidate = response.candidates.first,
let groundingMetadata = candidate.groundingMetadata {
// Get sources
let groundingChunks = groundingMetadata.groundingChunks
for chunk in groundingChunks {
if let maps = chunk.maps {
let title = maps.title // for example, "Heaven on 7th Marketplace"
let url = maps.url // for example, "https://maps.google.com/?cid=13100894621228039586"
let placeID = maps.placeID // for example, "places/ChIJ0-zA1vBZwokRon0fGj-6z7U"
// TODO(developer): show source in the UI
}
}
}
Kotlin
// ...
// Get the model's response
val text = response.text
// Get the grounding metadata
val groundingMetadata = response.candidates.firstOrNull()?.groundingMetadata
// Get sources
val groundingChunks = groundingMetadata?.groundingChunks
groundingChunks?.let { chunks ->
for (chunk in chunks) {
val title = chunk.maps?.title // for example, "Heaven on 7th Marketplace"
val uri = chunk.maps?.uri // for example, "https://maps.google.com/?cid=13100894621228039586"
val placeId = chunk.maps?.placeId // for example, "places/ChIJ0-zA1vBZwokRon0fGj-6z7U"
// TODO(developer): show source in the UI
}
}
Java
// ...
Futures.addCallback(response, new FutureCallback() {
@Override
public void onSuccess(GenerateContentResponse result) {
// Get the model's response
String text = result.getText();
// Get the grounding metadata
GroundingMetadata groundingMetadata =
result.getCandidates()[0].getGroundingMetadata();
if (groundingMetadata != null) {
// Get sources
List chunks = groundingMetadata.getGroundingChunks();
if (chunks != null) {
for(GroundingChunk chunk : chunks) {
GoogleMapsGroundingChunk maps = chunk.getMaps();
if (maps != null) {
String title = maps.getTitle(); // for example, "Heaven on 7th Marketplace"
String uri = maps.getUri(); // for example, "https://maps.google.com/?cid=13100894621228039586"
String placeId = maps.getPlaceId(); // for example, "places/ChIJ0-zA1vBZwokRon0fGj-6z7U"
// TODO(developer): show sources in the UI
}
}
}
}
}
@Override
public void onFailure(Throwable t) {
t.printStackTrace();
}
}, executor);
Web
// ...
// Get the model's text response
const text = result.response.text();
// Get the grounding metadata
const groundingMetadata = result.response.candidates?.[0]?.groundingMetadata;
// Get sources
const groundingChunks = groundingMetadata?.groundingChunks;
if (groundingChunks) {
for (const chunk of groundingChunks) {
const title = chunk.maps?.title; // for example, "Heaven on 7th Marketplace"
const uri = chunk.maps?.uri; // for example, "https://maps.google.com/?cid=13100894621228039586"
const placeId = chunk.maps?.placeId; // for example, "places/ChIJ0-zA1vBZwokRon0fGj-6z7U"
// TODO(developer): show sources in the UI
}
}
Dart
// ...
// Get the model's response
final text = response.text;
// Get the grounding metadata
final groundingMetadata = response.candidates.first.groundingMetadata;
// Get sources
final groundingChunks = groundingMetadata?.groundingChunks;
if (groundingChunks != null) {
for (var chunk in groundingChunks) {
final title = chunk.maps?.title; // for example, "Heaven on 7th Marketplace"
final uri = chunk.maps?.uri; // for example, "https://maps.google.com/?cid=13100894621228039586"
final placeId = chunk.maps?.placeId; // for example, "places/ChIJ0-zA1vBZwokRon0fGj-6z7U"
// TODO(developer): show sources in the UI
}
}
Unity
// ...
// Get the model's response.
var text = response.Text;
// Get the grounding metadata.
var groundingMetadata = response.Candidates.First().GroundingMetadata;
// Get sources.
if (groundingMetadata != null) {
foreach(GroundingChunk chunk in groundingMetadata?.GroundingChunks) {
if (chunk.Maps != null) {
var title = chunk.Maps?.Title; // for example, "Heaven on 7th Marketplace"
var uri = chunk.Maps?.Uri; // for example, "https://maps.google.com/?cid=13100894621228039586"
var placeId = chunk.Maps?.PlaceId; // for example, "places/ChIJ0-zA1vBZwokRon0fGj-6z7U"
// TODO(developer): show sources in the UI
}
}
}
Mostrar Google Maps fuentes con Google Maps vínculos
Para cada fuente en groundingChunks,
se debe generar una vista previa del vínculo que cumpla con los siguientes requisitos:
- Atribuye cada fuente a
Google Maps según los lineamientos de atribución de texto deGoogle Maps . - Muestra el título de la fuente proporcionado en la respuesta.
- Vincula a la fuente con el
uride la respuesta.
Puedes contraer la vista de las fuentes.
De manera opcional, puedes mejorar la vista previa del vínculo con contenido adicional, como el siguiente:
- Un favicón de
Google Maps insertado antes de la atribución de texto deGoogle Maps . - Una foto de la URL de origen (
og:image).
Para obtener más información sobre algunos de los proveedores de datos de
Google Maps lineamiento para la atribución de texto
Cuando atribuyas fuentes a
No modifiques el texto
Google Mapsde ninguna manera:- No cambies el uso de mayúsculas del texto
Google Maps. - No ajustes el texto
Google Mapsen varias líneas. - No localices el texto
Google Mapsa otro idioma. - Evita que los navegadores traduzcan el texto
Google Mapscon el atributo HTMLtranslate="no".
- No cambies el uso de mayúsculas del texto
Aplica diseño al texto
Google Mapscomo se describe en la siguiente tabla:Propiedad Estilo Familia de fuentes Roboto. La carga de la fuente es opcional. Familia de fuentes de resguardo Cualquier fuente sans serif para el cuerpo que ya se use en tu producto o "Sans-Serif" para invocar la fuente predeterminada del sistema Estilo de fuente Normal Grosor de la fuente 400 Color de la fuente Blanco, negro (#1F1F1F) o gris (#5E5E5E). Mantén un contraste accesible (4.5:1) con el fondo. Tamaño de fuente Tamaño de fuente mínimo: 12 sp
Tamaño de fuente máximo: 16 sp
Para obtener información sobre los sp, consulta las unidades de tamaño de fuente en el sitio web de Material Design.Espaciado Normal
Ejemplo de CSS
El siguiente código CSS renderiza el texto Google Maps con el estilo tipográfico y el color adecuados sobre un fondo blanco o claro.
@import url('https://fonts.googleapis.com/css2?family=Roboto&display=swap');
.GMP-attribution {
font-family: Roboto, Sans-Serif;
font-style: normal;
font-weight: 400;
font-size: 1rem;
letter-spacing: normal;
white-space: nowrap;
color: #5e5e5e;
}
Almacenamiento en caché del ID de lugar
El resultado fundamentado de
placeId
Las restricciones contra el almacenamiento en caché en las Condiciones de Fundamentación con Google Maps no se aplican a estos datos.
Actividades y territorios prohibidos
La fundamentación con
No usarás la Fundamentación con
Google Maps para actividades de alto riesgo, incluidos los servicios de emergencia.No distribuirás ni comercializarás tu aplicación que ofrece Fundamentación con
Google Maps en un Territorio prohibido. Para obtener más información, consulta Territorios prohibidos de Google Maps Platform. La lista de Territorios Prohibidos puede actualizarse periódicamente.
Resultados fundamentados y supervisión de la IA en la consola de Firebase
Si habilitaste la supervisión de la IA en la consola de Firebase, las respuestas se almacenan en Cloud Logging. De forma predeterminada, estos datos tienen un período de retención de 30 días.
Es tu responsabilidad asegurarte de que este período de retención o cualquier período personalizado que establezcas se alinee por completo con tu caso de uso específico y con cualquier requisito de cumplimiento adicional para el proveedor de Gemini API que elijas: Gemini Developer API o Agent Platform Gemini API (formerly Vertex AI) (consulta la sección Condiciones del Servicio en las Condiciones Específicas del Servicio). Es posible que debas ajustar el período de retención en Cloud Logging para cumplir con estos requisitos.
Precios y límites de frecuencia
Los precios de la fundamentación con
Asegúrate de revisar los detalles sobre los precios, la disponibilidad del modelo y los límites de
la fundamentación con