Investigación en arXiv

Busca y recupera artículos académicos de arXiv a través de su API REST gratuita. Sin API key, sin dependencias, solo curl.

Referencia rápida

Acción	Comando
Buscar artículos	`curl "https://export.arxiv.org/api/query?search_query=all:QUERY&max_results=5"`
Obtener artículo específico	`curl "https://export.arxiv.org/api/query?id_list=2402.03300"`
Leer resumen (web)	`web_extract(urls=["https://arxiv.org/abs/2402.03300"])`
Leer artículo completo (PDF)	`web_extract(urls=["https://arxiv.org/pdf/2402.03300"])`

Búsqueda de artículos

La API devuelve Atom XML. Puedes procesarlo con grep/sed o canalizarlo a Python para obtener una salida limpia.

Búsqueda básica

curl -s "https://export.arxiv.org/api/query?search_query=all:GRPO+reinforcement+learning&max_results=5"

Salida limpia (parsear XML a formato legible)

curl -s "https://export.arxiv.org/api/query?search_query=all:GRPO+reinforcement+learning&max_results=5&sortBy=submittedDate&sortOrder=descending" | python -c "
import sys, xml.etree.ElementTree as ET
ns = {'a': 'http://www.w3.org/2005/Atom'}
root = ET.parse(sys.stdin).getroot()
for i, entry in enumerate(root.findall('a:entry', ns)):
    title = entry.find('a:title', ns).text.strip().replace('\n', ' ')
    arxiv_id = entry.find('a:id', ns).text.strip().split('/abs/')[-1]
    published = entry.find('a:published', ns).text[:10]
    authors = ', '.join(a.find('a:name', ns).text for a in entry.findall('a:author', ns))
    summary = entry.find('a:summary', ns).text.strip()[:200]
    cats = ', '.join(c.get('term') for c in entry.findall('a:category', ns))
    print(f'{i+1}. [{arxiv_id}] {title}')
    print(f'   Autores: {authors}')
    print(f'   Publicado: {published} | Categorías: {cats}')
    print(f'   Resumen: {summary}...')
    print(f'   PDF: https://arxiv.org/pdf/{arxiv_id}')
    print()
"

Sintaxis de consulta de búsqueda

Prefijo	Busca en	Ejemplo
`all:`	Todos los campos	`all:transformer+attention`
`ti:`	Título	`ti:large+language+models`
`au:`	Autor	`au:vaswani`
`abs:`	Resumen	`abs:reinforcement+learning`
`cat:`	Categoría	`cat:cs.AI`
`co:`	Comentario	`co:accepted+NeurIPS`

Operadores booleanos

# Y (predeterminado al usar +)
search_query=all:transformer+attention

# O
search_query=all:GPT+OR+all:BERT

# Y NO
search_query=all:language+model+ANDNOT+all:vision

# Frase exacta
search_query=ti:"chain+of+thought"

# Combinado
search_query=au:hinton+AND+cat:cs.LG

Orden y paginación

Parámetro	Opciones
`sortBy`	`relevance`, `lastUpdatedDate`, `submittedDate`
`sortOrder`	`ascending`, `descending`
`start`	Desplazamiento de resultados (desde 0)
`max_results`	Número de resultados (predeterminado 10, máximo 30000)

# Últimos 10 artículos en cs.AI
curl -s "https://export.arxiv.org/api/query?search_query=cat:cs.AI&sortBy=submittedDate&sortOrder=descending&max_results=10"

Obtención de artículos específicos

# Por ID de arXiv
curl -s "https://export.arxiv.org/api/query?id_list=2402.03300"

# Varios artículos
curl -s "https://export.arxiv.org/api/query?id_list=2402.03300,2401.12345,2403.00001"

Generación de BibTeX

Después de obtener los metadatos de un artículo, genera una entrada BibTeX:

{% raw %}

curl -s "https://export.arxiv.org/api/query?id_list=1706.03762" | python -c "
import sys, xml.etree.ElementTree as ET
ns = {'a': 'http://www.w3.org/2005/Atom', 'arxiv': 'http://arxiv.org/schemas/atom'}
root = ET.parse(sys.stdin).getroot()
entry = root.find('a:entry', ns)
if entry is None: sys.exit('Artículo no encontrado')
title = entry.find('a:title', ns).text.strip().replace('\n', ' ')
authors = ' and '.join(a.find('a:name', ns).text for a in entry.findall('a:author', ns))
year = entry.find('a:published', ns).text[:4]
raw_id = entry.find('a:id', ns).text.strip().split('/abs/')[-1]
cat = entry.find('arxiv:primary_category', ns)
primary = cat.get('term') if cat is not None else 'cs.LG'
last_name = entry.find('a:author', ns).find('a:name', ns).text.split()[-1]
print(f'@article{{{last_name}{year}_{raw_id.replace(\".\", \"\")},')
print(f'  title     = {{{title}}},')
print(f'  author    = {{{authors}}},')
print(f'  year      = {{{year}}},')
print(f'  eprint    = {{{raw_id}}},')
print(f'  archivePrefix = {{arXiv}},')
print(f'  primaryClass  = {{{primary}}},')
print(f'  url       = {{https://arxiv.org/abs/{raw_id}}}')
print('}')
"

{% endraw %}

Lectura del contenido del artículo

Después de encontrar un artículo, léelo:

# Página de resumen (rápida, metadatos + resumen)
web_extract(urls=["https://arxiv.org/abs/2402.03300"])

# Artículo completo (PDF → markdown a través de Firecrawl)
web_extract(urls=["https://arxiv.org/pdf/2402.03300"])

Para procesamiento local de PDF, consulta el skill ocr-and-documents.

Categorías comunes

Categoría	Campo
`cs.AI`	Inteligencia Artificial
`cs.CL`	Computación y Lenguaje (NLP)
`cs.CV`	Visión por Computadora
`cs.LG`	Aprendizaje Automático
`cs.CR`	Criptografía y Seguridad
`stat.ML`	Aprendizaje Automático (Estadística)
`math.OC`	Optimización y Control
`physics.comp-ph`	Física Computacional

Lista completa: https://arxiv.org/category_taxonomy

Script auxiliar

El script scripts/search_arxiv.py maneja el análisis XML y proporciona una salida limpia:

python scripts/search_arxiv.py "GRPO reinforcement learning"
python scripts/search_arxiv.py "transformer attention" --max 10 --sort date
python scripts/search_arxiv.py --author "Yann LeCun" --max 5
python scripts/search_arxiv.py --category cs.AI --sort date
python scripts/search_arxiv.py --id 2402.03300
python scripts/search_arxiv.py --id 2402.03300,2401.12345

Sin dependencias: solo utiliza la biblioteca estándar de Python.

Semantic Scholar (Citas, trabajos relacionados, perfiles de autor)

arXiv no proporciona datos de citas ni recomendaciones. Usa la API de Semantic Scholar para eso: gratuita, sin clave para uso básico (1 req/segundo), devuelve JSON.

Obtener detalles del artículo + citas

# Por ID de arXiv
curl -s "https://api.semanticscholar.org/graph/v1/paper/arXiv:2402.03300?fields=title,authors,citationCount,referenceCount,influentialCitationCount,year,abstract" | python -m json.tool

# Por ID de Semantic Scholar o DOI
curl -s "https://api.semanticscholar.org/graph/v1/paper/DOI:10.1234/example?fields=title,citationCount"

Obtener citas DE un artículo (quién lo citó)

curl -s "https://api.semanticscholar.org/graph/v1/paper/arXiv:2402.03300/citations?fields=title,authors,year,citationCount&limit=10" | python -m json.tool

Obtener referencias DE un artículo (lo que cita)

curl -s "https://api.semanticscholar.org/graph/v1/paper/arXiv:2402.03300/references?fields=title,authors,year,citationCount&limit=10" | python -m json.tool

Buscar artículos (alternativa a la búsqueda de arXiv, devuelve JSON)

curl -s "https://api.semanticscholar.org/graph/v1/paper/search?query=GRPO+reinforcement+learning&limit=5&fields=title,authors,year,citationCount,externalIds" | python -m json.tool

Obtener recomendaciones de artículos

curl -s -X POST "https://api.semanticscholar.org/recommendations/v1/papers/" \
  -H "Content-Type: application/json" \
  -d '{"positivePaperIds": ["arXiv:2402.03300"], "negativePaperIds": []}' | python -m json.tool

Perfil de autor

curl -s "https://api.semanticscholar.org/graph/v1/author/search?query=Yann+LeCun&fields=name,hIndex,citationCount,paperCount" | python -m json.tool

Campos útiles de Semantic Scholar

title, authors, year, abstract, citationCount, referenceCount, influentialCitationCount, isOpenAccess, openAccessPdf, fieldsOfStudy, publicationVenue, externalIds (contiene arXiv ID, DOI, etc.)

Flujo de trabajo completo de investigación

Descubrir: python scripts/search_arxiv.py "tu tema" --sort date --max 10
Evaluar impacto: curl -s "https://api.semanticscholar.org/graph/v1/paper/arXiv:ID?fields=citationCount,influentialCitationCount"
Leer resumen: web_extract(urls=["https://arxiv.org/abs/ID"])
Leer artículo completo: web_extract(urls=["https://arxiv.org/pdf/ID"])
Encontrar trabajos relacionados: curl -s "https://api.semanticscholar.org/graph/v1/paper/arXiv:ID/references?fields=title,citationCount&limit=20"
Obtener recomendaciones: POST al endpoint de recomendaciones de Semantic Scholar
Seguir autores: curl -s "https://api.semanticscholar.org/graph/v1/author/search?query=NOMBRE"

Límites de velocidad

API	Velocidad	Autenticación
arXiv	~1 req / 3 segundos	Ninguna
Semantic Scholar	1 req / segundo	Ninguna (100/segundo con clave)

Notas

arXiv devuelve Atom XML: usa el script auxiliar o el fragmento de análisis para una salida limpia
Semantic Scholar devuelve JSON: canaliza a través de python -m json.tool para legibilidad
IDs de arXiv: formato antiguo (hep-th/0601001) vs. nuevo (2402.03300)
PDF: https://arxiv.org/pdf/{id} — Resumen: https://arxiv.org/abs/{id}
HTML (cuando está disponible): https://arxiv.org/html/{id}
Para procesamiento local de PDF, consulta el skill ocr-and-documents

Versionado de IDs

arxiv.org/abs/1706.03762 siempre resuelve a la última versión
arxiv.org/abs/1706.03762v1 apunta a una versión específica e inmutable
Al generar citas, conserva el sufijo de versión que realmente leíste para evitar desviaciones en las citas (una versión posterior puede cambiar sustancialmente el contenido)
El campo <id> de la API devuelve la URL versionada (ej., http://arxiv.org/abs/1706.03762v7)

Artículos retirados

Los artículos pueden ser retirados después de su envío. Cuando esto sucede:

El campo <summary> contiene un aviso de retiro (busca "withdrawn" o "retracted")
Los campos de metadatos pueden estar incompletos
Siempre verifica el resumen antes de tratar un resultado como un artículo válido

0x-Shashi/grok-skill-converter

¿Qué es grok-skill-converter?

Preguntar en tu IA favorita

Documentación