Verificación de fuentes y citas
Contraste de afirmaciones entre fuentes y asociación de las URL de las fuentes con los datos.
Verificación de fuentes y citas es una lección gratuita de AI Agents en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de AI Agents, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de AI Agents incluye 4 lecciones en total.
Por qué es importante verificar las fuentes
Un agente puede recuperar una afirmación falsa de una fuente de baja calidad y presentarla como un hecho. Sin verificación, el agente de investigación no es más que un motor de búsqueda sofisticado sin ningún filtro de calidad.
La verificación añade una capa que comprueba si las afirmaciones están corroboradas por varias fuentes independientes.
La regla de las dos fuentes
Una afirmación se considera verificada cuando aparece en al menos dos fuentes independientes. «Independientes» significa que pertenecen a dominios diferentes: encontrar la misma afirmación en dos sitios que citan el mismo artículo original no cuenta.
from urllib.parse import urlparse
def extract_domain(url: str) -> str:
return urlparse(url).netloc.replace('www.', '')
def is_verified(fact: str, all_facts: list[dict]) -> bool:
matching_domains = set()
for f in all_facts:
if fact.lower() in f['fact'].lower() or f['fact'].lower() in fact.lower():
matching_domains.add(extract_domain(f['source']))
return len(matching_domains) >= 2
# Example
facts = [
{'fact': 'Inflation peaked at 9.1% in June 2022', 'source': 'https://bls.gov/cpi'},
{'fact': 'US inflation hit 9.1% peak in mid-2022', 'source': 'https://reuters.com/article/a'}
]
print(is_verified('inflation peaked at 9.1%', facts)) # TrueCoincidencia semántica basada en LLM
La coincidencia de cadenas no detecta afirmaciones expresadas de otra manera. Use un LLM para determinar si dos datos son semánticamente equivalentes antes de contabilizarlos como fuentes corroborantes.
import openai, json
client = openai.OpenAI(api_key='YOUR_OPENAI_KEY')
def claims_are_equivalent(claim_a: str, claim_b: str) -> bool:
prompt = (
f'Are these two statements making the same factual claim?\n'
f'A: "{claim_a}"\n'
f'B: "{claim_b}"\n'
f'Answer JSON: {{"equivalent": true/false}}'
)
resp = client.chat.completions.create(
model='gpt-4o-mini',
messages=[{'role': 'user', 'content': prompt}],
response_format={'type': 'json_object'}
)
return json.loads(resp.choices[0].message.content).get('equivalent', False)
print(claims_are_equivalent(
'CPI hit 9.1% in June 2022',
'US consumer prices rose 9.1 percent year-over-year in June 2022'
)) # TruePuntuación de la calidad de las fuentes
No todas las fuentes tienen el mismo valor. Puntúe cada fuente según el tipo de dominio, la fecha de publicación y su fiabilidad conocida. Las fuentes de nivel 1, como las estadísticas gubernamentales y las revistas arbitradas por pares, deben tener más peso que los blogs o las redes sociales.
from datetime import datetime, timezone
HIGH_AUTHORITY_DOMAINS = [
'gov', 'edu', 'nature.com', 'science.org', 'pubmed.ncbi.nlm.nih.gov',
'reuters.com', 'bbc.com', 'apnews.com', 'who.int'
]
def score_source(url: str, publication_date: str | None) -> float:
score = 0.5 # baseline
domain = extract_domain(url)
tld = domain.split('.')[-1]
# Domain authority
if any(ha in domain for ha in HIGH_AUTHORITY_DOMAINS):
score += 0.3
elif tld in ('gov', 'edu', 'org'):
score += 0.1
# Recency
if publication_date:
try:
pub = datetime.fromisoformat(publication_date)
days_old = (datetime.now(timezone.utc) - pub.replace(tzinfo=timezone.utc)).days
if days_old < 365:
score += 0.1
elif days_old > 1825: # 5 years
score -= 0.1
except ValueError:
pass
return min(1.0, max(0.0, score))Contraste de afirmaciones con las fuentes
Para cada afirmación que el agente pretenda incluir en el informe final, contrástela con todos los documentos recuperados para encontrar las mejores fuentes corroborantes.
def cross_reference(claim: str, all_facts: list[dict]) -> list[dict]:
supporting = []
seen_domains = set()
for fact in all_facts:
if claims_are_equivalent(claim, fact['fact']):
domain = extract_domain(fact['source'])
if domain not in seen_domains: # only one per domain
seen_domains.add(domain)
supporting.append({
'source': fact['source'],
'domain': domain,
'fact': fact['fact'],
'score': score_source(fact['source'], fact.get('publication_date'))
})
return sorted(supporting, key=lambda x: x['score'], reverse=True)Comprobación de las credenciales de los autores
En el caso de afirmaciones científicas o médicas, las credenciales de los autores son importantes. Un estudio con autores identificados de instituciones acreditadas tiene más peso que una publicación anónima en un blog. Extraiga la información de los autores y marque las afirmaciones procedentes de fuentes anónimas.
def assess_authorship(url: str, page_text: str) -> dict:
prompt = (
f'From this webpage text, extract:\n'
f'1. Author name(s) (or null)\n'
f'2. Author affiliation/credentials (or null)\n'
f'3. Publication name (or null)\n'
f'Return JSON: {{"authors": [], "affiliation": null, "publication": null}}\n\n'
f'TEXT:\n{page_text[:2000]}'
)
resp = client.chat.completions.create(
model='gpt-4o-mini',
messages=[{'role': 'user', 'content': prompt}],
response_format={'type': 'json_object'}
)
return json.loads(resp.choices[0].message.content)Marcado de afirmaciones no verificadas
Las afirmaciones que no puedan contrastarse con dos fuentes independientes deben marcarse como no verificadas en el resultado. Según el nivel de riesgo del informe, las afirmaciones no verificadas pueden excluirse o presentarse con una advertencia.
def classify_claims(claims: list[str], all_facts: list[dict]) -> list[dict]:
classified = []
for claim in claims:
support = cross_reference(claim, all_facts)
classified.append({
'claim': claim,
'verified': len(support) >= 2,
'sources': support[:3], # top 3 supporting sources
'confidence': 'high' if len(support) >= 3 else
'medium' if len(support) == 2 else
'low'
})
return classifiedFormato de las citas: integradas y bibliografía
Los informes deben incluir citas integradas en el texto, mediante superíndices numerados, y una bibliografía al final. Genere ambas a partir de los metadatos de las fuentes verificadas.
def format_citations(classified_claims: list[dict]) -> tuple[list[str], list[str]]:
ref_list = []
ref_map = {} # url -> citation number
inline_claims = []
for item in classified_claims:
nums = []
for src in item['sources']:
url = src['source']
if url not in ref_map:
ref_map[url] = len(ref_list) + 1
ref_list.append(f'[{ref_map[url]}] {url}')
nums.append(f'[{ref_map[url]}]')
citation_str = ''.join(nums)
prefix = '' if item['verified'] else '[UNVERIFIED] '
inline_claims.append(f'{prefix}{item["claim"]} {citation_str}')
return inline_claims, ref_list
if __name__ == '__main__':
demo_claims = [
{'claim': 'Revenue grew 12% year over year', 'verified': True, 'sources': [{'source': 'https://example.com/report'}]},
{'claim': 'The CEO plans to step down', 'verified': False, 'sources': [{'source': 'https://example.com/rumor'}]},
]
inline, refs = format_citations(demo_claims)
for line in inline:
print(line)
print('References:')
for r in refs:
print(' ', r)
Detección de contradicciones entre fuentes
A veces, dos fuentes fiables se contradicen. Detecte las contradicciones y presente ambas perspectivas en lugar de elegir una en silencio. Esto es especialmente importante en el caso de afirmaciones empíricas controvertidas.
def find_contradictions(claim: str, all_facts: list[dict]) -> list[dict]:
contradictions = []
for fact in all_facts:
if extract_domain(fact['source']) == extract_domain(claim):
continue
prompt = (
f'Does fact B contradict fact A?\n'
f'A: "{claim}"\nB: "{fact["fact"]}"\n'
f'JSON: {{"contradicts": true/false}}'
)
resp = client.chat.completions.create(
model='gpt-4o-mini',
messages=[{'role': 'user', 'content': prompt}],
response_format={'type': 'json_object'}
)
result = json.loads(resp.choices[0].message.content)
if result.get('contradicts'):
contradictions.append(fact)
return contradictionsFicha de verificación
Antes de generar el informe final, prepare un resumen de verificación: cuántas afirmaciones se verificaron, cuántas no, cuáles son las principales fuentes según su puntuación de autoridad y qué contradicciones se detectaron.
def verification_report_card(classified: list[dict]) -> dict:
total = len(classified)
verified = sum(1 for c in classified if c['verified'])
all_sources = [
src for c in classified for src in c['sources']
]
top_domains = sorted(
set(s['domain'] for s in all_sources),
key=lambda d: max(s['score'] for s in all_sources if s['domain'] == d),
reverse=True
)[:5]
return {
'total_claims': total,
'verified': verified,
'unverified': total - verified,
'verification_rate': f'{verified/max(total,1)*100:.0f}%',
'top_sources': top_domains
}
if __name__ == '__main__':
demo_classified = [
{'verified': True, 'sources': [{'domain': 'docs.python.org', 'score': 1.3}]},
{'verified': False, 'sources': [{'domain': 'quora.com', 'score': 0.5}]},
]
card = verification_report_card(demo_classified)
for k, v in card.items():
print(f'{k}: {v}')
Resultado condicionado por el nivel de confianza
Establezca un umbral mínimo de verificación antes de publicar. Si se verifica menos del 70 % de las afirmaciones, pida al bucle de investigación que ejecute otra iteración centrada específicamente en las afirmaciones no verificadas.
MIN_VERIFICATION_RATE = 0.70
def should_run_more_research(classified: list[dict]) -> list[str]:
unverified = [c for c in classified if not c['verified']]
total = len(classified)
if total == 0:
return []
rate = (total - len(unverified)) / total
if rate >= MIN_VERIFICATION_RATE:
return [] # Sufficient confidence — stop
# Return search queries to verify remaining claims
return [f'verify: {c["claim"]}' for c in unverified[:3]]
if __name__ == '__main__':
demo_classified = [
{'claim': 'A', 'verified': True},
{'claim': 'B', 'verified': False},
{'claim': 'C', 'verified': False},
]
followups = should_run_more_research(demo_classified)
print('Follow-up queries needed:', followups)
¿Qué define a dos fuentes «independientes» según la regla de verificación de las dos fuentes?
El criterio de independencia evita una verificación basada en una cámara de eco, en la que la misma afirmación se remonta a una única fuente original citada por muchos medios.
Resumen de la verificación de fuentes
Una investigación verificada requiere: corroboración mediante dos fuentes de dominios diferentes, coincidencia semántica con LLM para detectar equivalencias expresadas de otra manera, puntuación de la calidad de las fuentes (autoridad del dominio + actualidad), detección de contradicciones y un resultado condicionado por el nivel de confianza que active más investigación si el porcentaje de verificación es demasiado bajo.
Preguntas frecuentes
¿La lección «Verificación de fuentes y citas» es gratis?
Sí — el texto completo de «Verificación de fuentes y citas» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de AI Agents, actualiza a CoddyKit PRO. El curso de AI Agents incluye 4 lecciones en total.
¿Qué aprenderé en «Verificación de fuentes y citas»?
Contraste de afirmaciones entre fuentes y asociación de las URL de las fuentes con los datos. Practicas AI Agents con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar AI Agents?
No se requiere experiencia previa. AI Agents en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.
¿Cuánto tiempo toma la lección «Verificación de fuentes y citas»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de AI Agents?
Sí. Cada lección de AI Agents incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Diseño de bucles de investigación en varios pasos
- Verificación de fuentes y citas
- Generación de informes estructurados
- Comprobación de datos y prevención de alucinaciones