Pesquisa no arXiv

Pesquise e recupere artigos acadêmicos do arXiv através de sua API REST gratuita. Sem chave de API, sem dependências — apenas curl.

Referência Rápida

Ação	Comando
Pesquisar artigos	`curl "https://export.arxiv.org/api/query?search_query=all:QUERY&max_results=5"`
Obter artigo específico	`curl "https://export.arxiv.org/api/query?id_list=2402.03300"`
Ler resumo (web)	`web_extract(urls=["https://arxiv.org/abs/2402.03300"])`
Ler artigo completo (PDF)	`web_extract(urls=["https://arxiv.org/pdf/2402.03300"])`

Pesquisando Artigos

A API retorna XML Atom. Analise com grep/sed ou encaminhe via python para saída limpa.

Pesquisa básica

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

Saída limpa (analisar XML para formato legível)

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} | Categorias: {cats}')
    print(f'   Resumo: {summary}...')
    print(f'   PDF: https://arxiv.org/pdf/{arxiv_id}')
    print()
"

Sintaxe de Consulta de Pesquisa

Prefixo	Pesquisa em	Exemplo
`all:`	Todos os campos	`all:transformer+attention`
`ti:`	Título	`ti:large+language+models`
`au:`	Autor	`au:vaswani`
`abs:`	Resumo	`abs:reinforcement+learning`
`cat:`	Categoria	`cat:cs.AI`
`co:`	Comentário	`co:accepted+NeurIPS`

Operadores booleanos

# AND (padrão ao usar +)
search_query=all:transformer+attention

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

# AND NOT
search_query=all:language+model+ANDNOT+all:vision

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

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

Ordenação e Paginação

Parâmetro	Opções
`sortBy`	`relevance`, `lastUpdatedDate`, `submittedDate`
`sortOrder`	`ascending`, `descending`
`start`	Deslocamento do resultado (base 0)
`max_results`	Número de resultados (padrão 10, máximo 30000)

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

Obtendo Artigos Específicos

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

# Múltiplos artigos
curl -s "https://export.arxiv.org/api/query?id_list=2402.03300,2401.12345,2403.00001"

Geração de BibTeX

Após obter os metadados de um artigo, gere uma entrada BibTeX:

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('Artigo não 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('}')
"

Lendo Conteúdo do Artigo

Após encontrar um artigo, leia-o:

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

# Artigo completo (PDF → markdown via Firecrawl)
web_extract(urls=["https://arxiv.org/pdf/2402.03300"])

Para processamento local de PDF, veja o skill ocr-and-documents.

Categorias Comuns

Categoria	Área
`cs.AI`	Inteligência Artificial
`cs.CL`	Computação e Linguagem (PLN)
`cs.CV`	Visão Computacional
`cs.LG`	Aprendizado de Máquina
`cs.CR`	Criptografia e Segurança
`stat.ML`	Aprendizado de Máquina (Estatística)
`math.OC`	Otimização e Controle
`physics.comp-ph`	Física Computacional

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

Script Auxiliar

O script scripts/search_arxiv.py lida com a análise XML e fornece saída limpa:

python scripts/search_arxiv.py "Aprendizado por Reforço GRPO"
python scripts/search_arxiv.py "atenção transformer" --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

Sem dependências — usa apenas a stdlib do Python.

Semantic Scholar (Citações, Artigos Relacionados, Perfis de Autores)

O arXiv não fornece dados de citação ou recomendações. Use a API Semantic Scholar para isso — gratuita, sem chave necessária para uso básico (1 req/seg), retorna JSON.

Obter detalhes do artigo + citações

# Por ID 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 do artigo Semantic Scholar ou DOI
curl -s "https://api.semanticscholar.org/graph/v1/paper/DOI:10.1234/example?fields=title,citationCount"

Obter citações DE um artigo (quem o citou)

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

Obter referências DE UM artigo (o que ele 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

Pesquisar artigos (alternativa à pesquisa arXiv, retorna 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

Obter recomendações de artigos

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 do autor

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

Campos úteis do Semantic Scholar

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

Fluxo de Trabalho de Pesquisa Completo

Descobrir: python scripts/search_arxiv.py "seu tópico" --sort date --max 10
Avaliar impacto: curl -s "https://api.semanticscholar.org/graph/v1/paper/arXiv:ID?fields=citationCount,influentialCitationCount"
Ler resumo: web_extract(urls=["https://arxiv.org/abs/ID"])
Ler artigo completo: web_extract(urls=["https://arxiv.org/pdf/ID"])
Encontrar trabalhos relacionados: curl -s "https://api.semanticscholar.org/graph/v1/paper/arXiv:ID/references?fields=title,citationCount&limit=20"
Obter recomendações: POST para o endpoint de recomendações do Semantic Scholar
Rastrear autores: curl -s "https://api.semanticscholar.org/graph/v1/author/search?query=NOME"

Limites de Taxa

API	Taxa	Autenticação
arXiv	~1 req / 3 segundos	Nenhuma necessária
Semantic Scholar	1 req / segundo	Nenhuma (100/seg com chave de API)

Notas

O arXiv retorna XML Atom — use o script auxiliar ou trecho de análise para saída limpa
O Semantic Scholar retorna JSON — encaminhe via python -m json.tool para legibilidade
IDs arXiv: formato antigo (hep-th/0601001) vs novo (2402.03300)
PDF: https://arxiv.org/pdf/{id} — Resumo: https://arxiv.org/abs/{id}
HTML (quando disponível): https://arxiv.org/html/{id}
Para processamento local de PDF, veja o skill ocr-and-documents

Versionamento de ID

arxiv.org/abs/1706.03762 sempre resolve para a versão mais recente
arxiv.org/abs/1706.03762v1 aponta para uma versão específica e imutável
Ao gerar citações, preserve o sufixo de versão que você realmente leu para evitar desvio de citação (uma versão posterior pode alterar substancialmente o conteúdo)
O campo <id> da API retorna a URL versionada (ex.: http://arxiv.org/abs/1706.03762v7)

Artigos Retirados

Artigos podem ser retirados após a submissão. Quando isso acontece:

O campo <summary> contém um aviso de retirada (procure por "withdrawn" ou "retracted")
Os campos de metadados podem estar incompletos
Sempre verifique o resumo antes de tratar um resultado como um artigo válido

0x-Shashi/grok-skill-converter

O que é grok-skill-converter?

Perguntar na sua IA favorita

Documentação