Recherche arXiv

Recherchez et récupérez des articles académiques depuis arXiv via leur API REST gratuite. Pas de clé API, pas de dépendances — juste curl.

Référence rapide

Action	Commande
Rechercher des articles	`curl "https://export.arxiv.org/api/query?search_query=all:QUERY&max_results=5"`
Obtenir un article spécifique	`curl "https://export.arxiv.org/api/query?id_list=2402.03300"`
Lire le résumé (web)	`web_extract(urls=["https://arxiv.org/abs/2402.03300"])`
Lire l'article complet (PDF)	`web_extract(urls=["https://arxiv.org/pdf/2402.03300"])`

Recherche d'articles

L'API renvoie du XML Atom. Analysez avec grep/sed ou passez par python pour une sortie propre.

Recherche basique

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

Sortie propre (analyse XML en format lisible)

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'   Auteurs : {authors}')
    print(f'   Publié le : {published} | Catégories : {cats}')
    print(f'   Résumé : {summary}...')
    print(f'   PDF : https://arxiv.org/pdf/{arxiv_id}')
    print()
"

Syntaxe des requêtes de recherche

Préfixe	Recherche	Exemple
`all:`	Tous les champs	`all:transformer+attention`
`ti:`	Titre	`ti:large+language+models`
`au:`	Auteur	`au:vaswani`
`abs:`	Résumé	`abs:reinforcement+learning`
`cat:`	Catégorie	`cat:cs.AI`
`co:`	Commentaire	`co:accepted+NeurIPS`

Opérateurs booléens

# ET (par défaut en utilisant +)
search_query=all:transformer+attention

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

# ET NON
search_query=all:language+model+ANDNOT+all:vision

# Expression exacte
search_query=ti:"chain+of+thought"

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

Tri et pagination

Paramètre	Options
`sortBy`	`relevance`, `lastUpdatedDate`, `submittedDate`
`sortOrder`	`ascending`, `descending`
`start`	Décalage des résultats (base 0)
`max_results`	Nombre de résultats (défaut 10, max 30000)

# Les 10 derniers articles en cs.AI
curl -s "https://export.arxiv.org/api/query?search_query=cat:cs.AI&sortBy=submittedDate&sortOrder=descending&max_results=10"

Récupération d'articles spécifiques

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

# Plusieurs articles
curl -s "https://export.arxiv.org/api/query?id_list=2402.03300,2401.12345,2403.00001"

Génération de BibTeX

Après avoir récupéré les métadonnées d'un article, générez une entrée 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('Article non trouvé')
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('}')
"

Lecture du contenu de l'article

Après avoir trouvé un article, lisez-le :

# Page de résumé (rapide, métadonnées + résumé)
web_extract(urls=["https://arxiv.org/abs/2402.03300"])

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

Pour le traitement local de PDF, voir la compétence ocr-and-documents.

Catégories courantes

Catégorie	Domaine
`cs.AI`	Intelligence Artificielle
`cs.CL`	Calcul et Langage (TALN)
`cs.CV`	Vision par Ordinateur
`cs.LG`	Apprentissage Automatique
`cs.CR`	Cryptographie et Sécurité
`stat.ML`	Apprentissage Automatique (Statistiques)
`math.OC`	Optimisation et Contrôle
`physics.comp-ph`	Physique Computationnelle

Liste complète : https://arxiv.org/category_taxonomy

Script d'aide

Le script scripts/search_arxiv.py gère l'analyse XML et fournit une sortie propre :

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

Aucune dépendance — utilise uniquement la bibliothèque standard de Python.

Semantic Scholar (Citations, Articles connexes, Profils d'auteurs)

arXiv ne fournit pas de données de citation ni de recommandations. Utilisez l'API Semantic Scholar pour cela — gratuit, pas de clé nécessaire pour un usage basique (1 req/s), renvoie du JSON.

Obtenir les détails d'un article + citations

# Par 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

# Par ID d'article Semantic Scholar ou DOI
curl -s "https://api.semanticscholar.org/graph/v1/paper/DOI:10.1234/example?fields=title,citationCount"

Obtenir les citations D'UN article (qui l'a 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

Obtenir les références D'UN article (ce qu'il cite)

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

Rechercher des articles (alternative à la recherche arXiv, renvoie du 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

Obtenir des recommandations d'articles

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

Profil d'auteur

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

Champs Semantic Scholar utiles

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

Flux de travail de recherche complet

Découvrir : python scripts/search_arxiv.py "votre sujet" --sort date --max 10
Évaluer l'impact : curl -s "https://api.semanticscholar.org/graph/v1/paper/arXiv:ID?fields=citationCount,influentialCitationCount"
Lire le résumé : web_extract(urls=["https://arxiv.org/abs/ID"])
Lire l'article complet : web_extract(urls=["https://arxiv.org/pdf/ID"])
Trouver des travaux connexes : curl -s "https://api.semanticscholar.org/graph/v1/paper/arXiv:ID/references?fields=title,citationCount&limit=20"
Obtenir des recommandations : POST vers le point de terminaison des recommandations Semantic Scholar
Suivre les auteurs : curl -s "https://api.semanticscholar.org/graph/v1/author/search?query=NOM"

Limites de débit

API	Débit	Authentification
arXiv	~1 req / 3 secondes	Aucune
Semantic Scholar	1 req / seconde	Aucune (100/sec avec clé API)

Notes

arXiv renvoie du XML Atom — utilisez le script d'aide ou l'extrait d'analyse pour une sortie propre
Semantic Scholar renvoie du JSON — passez par python -m json.tool pour la lisibilité
IDs arXiv : format ancien (hep-th/0601001) vs nouveau (2402.03300)
PDF : https://arxiv.org/pdf/{id} — Résumé : https://arxiv.org/abs/{id}
HTML (quand disponible) : https://arxiv.org/html/{id}
Pour le traitement local de PDF, voir la compétence ocr-and-documents

Gestion des versions d'ID

arxiv.org/abs/1706.03762 pointe toujours vers la dernière version
arxiv.org/abs/1706.03762v1 pointe vers une version spécifique et immuable
Lors de la génération de citations, conservez le suffixe de version que vous avez réellement lu pour éviter la dérive de citation (une version ultérieure peut modifier considérablement le contenu)
Le champ <id> de l'API renvoie l'URL versionnée (par exemple, http://arxiv.org/abs/1706.03762v7)

Articles retirés

Les articles peuvent être retirés après soumission. Dans ce cas :

Le champ <summary> contient un avis de retrait (cherchez "withdrawn" ou "retracted")
Les champs de métadonnées peuvent être incomplets
Vérifiez toujours le résumé avant de traiter un résultat comme un article valide

0x-Shashi/grok-skill-converter

Qu'est-ce que grok-skill-converter ?

Demander à votre IA préférée

Documentation