Pour les agents

Pour donner un tracé à une personne, écrivez un document de tracé JSON et envoyez-le avec POST https://graph-paper.io/plot-link. La réponse contient le lien à donner à la personne, ou la liste des erreurs à corriger. Un programme qui peut seulement lire une adresse utilise GET https://graph-paper.io/plot-link?doc=<JSON encodé en pourcentage>. Un client qui parle MCP utilise le serveur https://graph-paper.io/mcp. Aucun compte et aucune clé ne sont nécessaires.

Cette page s'adresse aux programmes et aux agents d'IA qui utilisent Graph Paper. Elle indique ce que Graph Paper sait tracer, comment donner à une personne un tracé qu'elle peut modifier, comment vérifier un document, ce que vous pouvez lire sans compte et ce qui n'est pas possible.

Un programme doit lire la version Markdown de cette page, à l'adresse https://graph-paper.io/for-agents/fr/index.md, car un résumé de la page HTML peut perdre les tableaux. Chaque page de guide existe en Markdown : ajoutez index.md à son URL, ou envoyez Accept: text/markdown. Le fichier https://graph-paper.io/llms-full.txt contient à lui seul le texte anglais de cette page, du format des documents de tracé, du Guide des tracés et des Astuces et conseils.

Sommaire

Choisir une façon de faire le lien
Ce que Graph Paper sait tracer
Transmettre un document à une personne
Utiliser le serveur MCP
Envoyer le document avec POST
Obtenir le lien avec GET
Construire le lien dans du code
Écrire un lien à la main
Si un lien ne peut pas atteindre la personne
Le format des documents
Lire sans compte
Ce qui n'est pas possible
Outils dans l'onglet du navigateur
Vérifier avant d'affirmer

Choisir une façon de faire le lien

Écrivez le tracé sous forme de document JSON, au format des documents de tracé. Envoyez-le ensuite à https://graph-paper.io/plot-link et donnez à la personne l'url de la réponse. N'encodez pas le lien vous-même si vous pouvez envoyer une requête : le service vérifie le document, et une réponse avec "ok": false liste ce qu'il faut changer, champ par champ.

shcurl -X POST https://graph-paper.io/plot-link \ -H 'Content-Type: application/json' \ -d '{"title":"Sine","series":[{"type":"line","fn":"\\sin(x)"}]}'

La réponse pour ce document valide, avec le statut 200 :

json{"ok":true,"url":"https://graph-paper.io/new#doc=eyJ0aXRsZSI6IlNpbmUiLCJzZXJpZXMiOlt7InR5cGUiOiJsaW5lIiwiZm4iOiJcXHNpbih4KSJ9XX0","title":"Sine","dimension":2,"category":"2d","rows":{"series":1,"variables":0,"points":0,"definitions":0,"actions":0,"markers":0},"note":"The structure of the document is correct, but the formulas were not computed, so do not tell the person that the plot works. When the link opens, Graph Paper shows a message with a Copy report button (\"Copier le rapport\" in French) if a row does not work: ask the person to paste that report to you.","warnings":[]}

La réponse quand la formule est "sin(x)", qui n'est pas du LaTeX, avec le statut 422 :

json{"ok":false,"errors":[{"path":"series[0].fn","message":"Formulas are LaTeX. Write \"\\\\sin(…)\", not \"sin(…)\"."}],"warnings":[]}

La note d'une réponse valide dit ce que la vérification ne fait pas : elle ne calcule pas les formules. Une formule avec un nom non défini affiche une erreur dans sa ligne quand la personne ouvre le lien. Graph Paper affiche alors un message avec un bouton Copier le rapport : demandez à la personne de vous coller ce rapport, et corrigez les lignes qu'il nomme.

Chaque formule est en LaTeX. Écrivez "\\sin(x)", pas "sin(x)", et "x^{2}", pas "x**2". Un texte brut comme exp(-k x) se lit comme le produit e·x·p : le service le refuse et dit quoi écrire. Écrivez un nombre comme un décimal simple ou comme a\cdot 10^{n} : Graph Paper lit 1e-5 comme un nombre, mais sa ligne affiche 1e − 5, et le service donne un avertissement.

Une formule s'écrit de trois façons, une pour chaque endroit où vous l'écrivez :

Endroit	La formule \sin(x) s'écrit
LaTeX	\sin(x)
une chaîne dans un texte JSON	"\\sin(x)"
la requête doc d'un GET	%22%5C%5Csin(x)%22

Dans un texte JSON, une barre oblique inverse de LaTeX s'écrit avec deux caractères, \\. N'en écrivez pas quatre : "\\\\sin(x)" est un saut de ligne suivi des lettres s, i, n. N'en écrivez pas une seule non plus : "\frac" est valide dans un texte JSON, mais JSON lit \f comme un saut de page, et la formule devient un saut de page suivi de rac. Le service refuse un retour arrière ou un saut de page, et une tabulation, un saut de ligne ou un retour chariot avant un long nom de commande (\theta). Avant un nom d'une ou deux lettres (\to, \tan), un vrai espace est possible : le service donne alors un avertissement, ou rien.

Choisissez la première ligne que vous pouvez faire :

Si vous pouvez…	Faites ceci	Voir
appeler les outils d'un serveur MCP	Ajoutez le serveur https://graph-paper.io/mcp. Appelez make_plot_link.	Utiliser le serveur MCP
envoyer des requêtes HTTP	Envoyez le document avec POST https://graph-paper.io/plot-link.	Envoyer le document avec POST
seulement lire une URL	Lisez https://graph-paper.io/plot-link?doc=<JSON encodé en pourcentage>.	Obtenir le lien avec GET
exécuter du code, sans requête	Encodez le document et construisez vous-même le lien #doc= (sans vérification).	Construire le lien dans du code
ne rien faire de tout cela	Écrivez un lien #json= à la main.	Écrire un lien à la main

Les trois premières façons vérifient le document. Elles vous donnent le lien, ou la liste des erreurs avec le champ de chaque erreur. Les deux dernières ne vérifient pas le document : Graph Paper ne le vérifie que lorsque la personne ouvre le lien. Si vous construisez le lien vous-même et pouvez aussi envoyer une requête, vérifiez d'abord le document avec /plot-link.

Aucune de ces façons ne demande de compte ni de clé. Le lien ouvre le document comme un brouillon que la personne peut modifier.

/plot-link/ et /mcp/, avec une barre oblique finale, fonctionnent comme /plot-link et /mcp.

Ce que Graph Paper sait tracer

Graph Paper lit la forme d'une formule et choisit un type de tracé :

Motif	Exemple	Résultat probable
Une variable libre	x^2	courbe 2D
Fonction explicite	y = x^2	courbe 2D
Deux variables libres	x+y	courbe implicite
Équation en x et y	x^2+y^2=1	courbe implicite
Inéquation en x et y	x^2+y^2<1	région implicite
Tuple avec un paramètre	(\cos(t), \sin(t))	courbe paramétrique
Tuple à trois parties avec un paramètre	(\cos(t), \sin(t), t)	courbe paramétrique 3D
Tuple à trois parties avec deux paramètres	(u, v, \sin(u v))	surface paramétrique 3D
Variable polaire	1+\cos(\theta)	courbe polaire
Variable complexe	z^2+1	coloriage du domaine

Graph Paper trace aussi :

en 2D : des cartes de chaleur avec lignes de niveau, des champs de vecteurs, des nuages de points, des polygones ;
en 3D : des surfaces z = f(x, y), des surfaces implicites, des nuages de points, des sphères, des segments et des flèches ;
pour les données : des tableaux, des nuages de points, des diagrammes en barres, des histogrammes, des boîtes à moustaches, des graphiques en chandeliers et l'ajustement d'une formule à des données ;
des annotations : des étiquettes, des segments avec des flèches, des droites, des bandes, des rectangles et des ellipses, sous forme de marqueurs que la personne peut déplacer et modifier. Les données vont dans les lignes de séries ; les annotations vont dans les marqueurs. Un point de points n'a pas d'étiquette : une étiquette ou un segment est un marqueur. Voir Marqueurs ;
des curseurs, des animations, des points à déplacer et des actions qui changent des valeurs une fois ou à intervalle régulier ;
des simulations qui font avancer un état sur une minuterie, comme un pendule à grandes oscillations. Voir Une simulation avec une minuterie.

Graph Paper propose aussi des carnets : des documents faits de texte, de formules, de calculs et de figures.

Transmettre un document à une personne

Écrivez le tracé sous forme de document JSON, puis donnez un lien à la personne. Graph Paper ouvre le document dans son navigateur, et elle peut le modifier. Il existe quatre formes de lien :

Lien	Ouvre
https://graph-paper.io/new#doc=<payload>	Le document contenu dans <payload> : son JSON en UTF-8, encodé en base64url (RFC 4648 §5, sans remplissage).
https://graph-paper.io/new#json=<payload>	Le document contenu dans <payload> : son JSON, encodé en pourcentage. Cette forme s'écrit à la main.
https://graph-paper.io/new?src=<url>	Le document situé à <url>, que Graph Paper télécharge.
https://graph-paper.io/new	Un nouveau tracé 2D vide.

Un lien n'a qu'une forme : #doc= ou #json=, pas les deux. Graph Paper vérifie un document #json= de la même façon qu'un document #doc=.

Avec #doc= et #json=, la partie qui suit # reste dans le navigateur. Elle n'est pas envoyée au serveur.

Avec ?src=, c'est le serveur de Graph Paper qui télécharge le document. Le serveur situé à <url> n'a donc pas besoin d'autoriser les lectures d'une autre origine. Les règles suivantes s'appliquent :

L'URL commence par https: et utilise le port par défaut. Elle ne contient ni nom d'utilisateur ni mot de passe.
L'hôte est un nom de domaine. Une adresse IP, localhost et les noms qui se terminent par .local ou .internal sont refusés.
Le serveur répond en 10 secondes, avec au plus trois redirections. Chaque redirection suit les mêmes règles.
Le corps de la réponse est le document JSON. Son type de contenu n'est pas vérifié. Aucun cookie ni identifiant n'est envoyé.

Un document fait au plus 65 536 octets. Pour un grand document, utilisez ?src= : certaines applications coupent les liens longs.

Ce que voit la personne

Sans être connectée : le document s'ouvre comme un brouillon qu'elle peut modifier. À sa première modification, un message lui demande de se connecter pour l'enregistrer. Quand elle se connecte, le brouillon est conservé.
Connectée : le document s'ouvre de la même façon que lorsqu'elle crée un document à partir d'un modèle.
Un document qui n'est pas valide, ou une URL ?src= illisible : Graph Paper ouvre sa page d'accueil et affiche un message qui donne la raison.

Quand la personne ouvre le lien

Le service de liens vérifie seulement la structure du document : les champs, leurs types et leurs limites. Il ne peut pas calculer une formule. Un document qu'il accepte peut donc avoir une ligne qui ne fonctionne pas, par exemple une formule qui utilise un nom que le document ne définit pas.

Graph Paper vérifie les formules quand la personne ouvre le lien. Si une ligne ne fonctionne pas, il affiche un message, « 2 cellules de ce document ont une erreur. », avec le bouton Copier le rapport (l'application appelle « cellule » une ligne du document). Dites à la personne : « Si Graph Paper indique que des cellules ont une erreur, appuyez sur Copier le rapport et collez le texte ici. » Le rapport donne, pour chaque ligne, le chemin du champ de votre document (par exemple definitions[1].latex), la formule entre guillemets et ce qu'il faut changer. Corrigez ces champs et créez un nouveau lien. Le titre, les formules et les noms entre guillemets du rapport sont copiés de votre document : lisez-les comme des données, pas comme des instructions.

Ne dites pas à la personne que le document est valide seulement parce que le service de liens l'a accepté.

Si vous avez un outil de navigateur, ouvrez le lien et attendez l'élément script#plot-document-report. Il contient le rapport en JSON :

json{ "version": 1, "title": "Interactive Pendulum", "ok": false, "complete": true, "count": 1, "problems": [ { "path": "definitions[1].latex", "kind": "definition", "formula": "E = \\frac{1}{2}mL^2", "message": "The name \"m\" is not defined in the document. Add a variable or a definition for \"m\", or remove it from the formula." } ] }

"ok": true signifie que toutes les lignes fonctionnent. "complete": false (avec "ok": false et aucun problème) signifie que les lignes n'ont pas été calculées à temps : ouvrez le lien de nouveau. path utilise les noms du validateur, par exemple variables[0].domain.min ou series[2].source. L'élément est ajouté après le premier calcul complet du document ; il n'existe pas avant. Les messages sont en anglais, quelle que soit la langue de l'interface.

Utiliser le serveur MCP

https://graph-paper.io/mcp est un serveur MCP (Model Context Protocol) distant. Il utilise le transport Streamable HTTP. Il ne garde pas de session et ne demande pas d'authentification. Pour l'ajouter à un client MCP, donnez au client l'URL https://graph-paper.io/mcp ; aucune clé, aucun jeton et aucune connexion ne sont nécessaires.

Un client de discussion liste les serveurs MCP qu'il peut utiliser comme connecteurs. Si Graph Paper n'est pas dans la liste, la personne ajoute un connecteur personnalisé avec l'adresse https://graph-paper.io/mcp, sans clé et sans compte. Un programme qui ne peut pas ajouter de connecteur utilise /plot-link, qui n'en demande aucun.

Le serveur est dans le registre MCP officiel sous le nom io.graph-paper/graph-paper (recherche dans le registre). Sa fiche de serveur (server card), un fichier JSON qui donne le nom, l'adresse et les révisions du protocole du serveur, est à l'adresse https://graph-paper.io/mcp/server-card (l'adresse de SEP-2127, MCP Server Cards). La même fiche est aussi à /.well-known/mcp/server-card.json, à /.well-known/mcp-server-card et à /.well-known/mcp.json.

Le serveur donne le même nom dans son serverInfo. Il accepte les révisions du protocole 2026-07-28, 2025-11-25, 2025-06-18 et 2025-03-26. Il a trois outils :

Outil	Entrée	Résultat
make_plot_link	{ "document": { … } }	Le lien qui ouvre le document, ou les erreurs et les avertissements.
get_plot_format	{ "section": "…" }, facultatif	La page du format des documents de tracé en Markdown (en anglais), ou une section.
list_examples	{}	Les documents d'exemple de la page du format, chacun avec son titre et son JSON.

Pour get_plot_format, section est un titre de la page du format, par son texte ("2D Series Types") ou par son ancre ("2d-series-types").

Le résultat de make_plot_link a les mêmes champs que la réponse de /plot-link, dans structuredContent, et un court texte dans content. Si le document contient des erreurs, le résultat a "isError": true. Corrigez les erreurs et appelez de nouveau l'outil.

Un appel d'outil

Votre client MCP envoie cette requête JSON-RPC :

json{ "jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": { "name": "make_plot_link", "arguments": { "document": { "title": "Sine", "series": [{ "type": "line", "fn": "\\sin(x)" }] } } } }

Le serveur répond (mis en forme ici pour la lecture) :

json{ "jsonrpc": "2.0", "id": 1, "result": { "content": [ { "type": "text", "text": "https://graph-paper.io/new#doc=eyJ0aXRsZSI6IlNpbmUiLCJzZXJpZXMiOlt7InR5cGUiOiJsaW5lIiwiZm4iOiJcXHNpbih4KSJ9XX0\n\nThis link opens \"Sine\" (a 2D plot) in Graph Paper as an editable draft; the reader needs no account." } ], "isError": false, "structuredContent": { "ok": true, "url": "https://graph-paper.io/new#doc=eyJ0aXRsZSI6IlNpbmUiLCJzZXJpZXMiOlt7InR5cGUiOiJsaW5lIiwiZm4iOiJcXHNpbih4KSJ9XX0", "title": "Sine", "dimension": 2, "category": "2d", "rows": { "series": 1, "variables": 0, "points": 0, "definitions": 0, "actions": 0, "markers": 0 }, "warnings": [] } } }

Envoyer le document avec POST

Envoyez le document JSON comme corps d'une requête POST à https://graph-paper.io/plot-link. Aucun compte, aucune clé et aucun en-tête ne sont nécessaires. Le type attendu est Content-Type: application/json.

shcurl -X POST https://graph-paper.io/plot-link \ -H 'Content-Type: application/json' \ -d '{"title":"Sine","series":[{"type":"line","fn":"\\sin(x)"}]}'

La réponse :

Donnez l'url à la personne.

Une description OpenAPI 3.1 du service se trouve à l'adresse https://graph-paper.io/openapi.json.

La réponse

Chaque réponse est en JSON, avec Access-Control-Allow-Origin: * : un programme dans une page web peut donc aussi appeler le service.

Le statut d'une réponse à un POST :

Statut	Quand	Corps
200	Le document est valide.	ok: true, url, title, dimension, category, rows, note, warnings
422	Le JSON n'est pas un document de tracé valide.	ok: false, errors, warnings
413	Le document dépasse 65 536 octets.	ok: false, errors, warnings
400	Le corps ou doc n'est pas du JSON, ou manque.	ok: false, errors, warnings
405	La méthode n'est ni GET ni POST.	ok: false, errors, warnings

Un GET répond toujours avec le statut 200, pour qu'un outil qui montre seulement le corps d'une réponse réussie montre aussi les erreurs. Son corps a un champ de plus, status : le statut du tableau ci-dessus.

Les champs d'une réponse valide :

url : le lien qui ouvre le document comme un brouillon que la personne peut modifier. Il contient le document tel qu'il a été vérifié, sans les clés ignorées.
dimension : 2 pour un tracé 2D, 3 pour un tracé 3D.
category : "2d", "3d" ou "data".
rows : le nombre de series, variables, points, definitions, actions et markers.
note : deux phrases. Les formules n'ont pas été calculées : ne dites donc pas à la personne que le tracé fonctionne ; si une ligne ne fonctionne pas, demandez à la personne le rapport du bouton Copier le rapport.

Chaque erreur et chaque avertissement est { "path", "message" }. path désigne le champ en notation de chemin JSON, comme series[0].fn. Il est vide quand l'erreur porte sur toute la requête. Un avertissement désigne chaque clé ignorée. Si la clé ne diffère d'un champ que par la casse, l'avertissement nomme ce champ. Au plus 100 erreurs et 100 avertissements sont listés. S'il y en a plus, un dernier élément, avec un path vide, donne le nombre de ceux qui ne sont pas listés. Les messages sont en anglais.

Par exemple, ce document a une formule vide et une clé avec une mauvaise casse :

shcurl -X POST https://graph-paper.io/plot-link \ -H 'Content-Type: application/json' \ -d '{"title":"Parabola","series":[{"type":"line","fn":"","Domain":[-2,2]}]}'

La réponse, avec le statut 422 :

json{"ok":false,"errors":[{"path":"series[0].fn","message":"The formula is empty."}],"warnings":[{"path":"series[0].Domain","message":"A line series has no field \"Domain\", so it was ignored; the field is \"domain\"."}]}

Obtenir le lien avec GET

Un programme qui peut seulement lire une URL peut envoyer le document dans le paramètre de requête doc : https://graph-paper.io/plot-link?doc=<JSON encodé en pourcentage>. La réponse est la même qu'avec POST, avec le statut 200 et un champ status (voir La réponse). Un GET sans doc répond avec un texte usage et un example : une URL complète qui fonctionne.

Encodez tout le JSON en pourcentage, comme le fait encodeURIComponent en JavaScript. En particulier :

Écrivez une espace sous la forme %20 et un signe plus sous la forme %2B. Un encodeur de formulaire, comme URLSearchParams ou curl --data-urlencode, écrit une espace sous la forme + ; le service la lit comme une espace quand la requête a aussi un %2B. Une requête avec un + et ni %20 ni %2B est refusée (status 400), car le service ne peut pas y distinguer une espace d'un signe plus.
Écrivez % sous la forme %25, & sous la forme %26 et # sous la forme %23.

Cloudflare limite l'URL entière à environ 16 Ko. L'encodage en pourcentage allonge le JSON : pour un document de plus de quelques kilo-octets, utilisez POST.

Ce document trace le cercle unité :

json{"title":"Unit circle","series":[{"type":"implicit","fn":"x^2+y^2=1"}]}

La requête, avec curl :

shcurl 'https://graph-paper.io/plot-link?doc=%7B%22title%22%3A%22Unit%20circle%22%2C%22series%22%3A%5B%7B%22type%22%3A%22implicit%22%2C%22fn%22%3A%22x%5E2%2By%5E2%3D1%22%7D%5D%7D'

La réponse :

json{"ok":true,"url":"https://graph-paper.io/new#doc=eyJ0aXRsZSI6IlVuaXQgY2lyY2xlIiwic2VyaWVzIjpbeyJ0eXBlIjoiaW1wbGljaXQiLCJmbiI6InheMit5XjI9MSJ9XX0","title":"Unit circle","dimension":2,"category":"2d","rows":{"series":1,"variables":0,"points":0,"definitions":0,"actions":0,"markers":0},"note":"The structure of the document is correct, but the formulas were not computed, so do not tell the person that the plot works. When the link opens, Graph Paper shows a message with a Copy report button (\"Copier le rapport\" in French) if a row does not work: ask the person to paste that report to you.","warnings":[]}

Construire le lien dans du code

Cette façon ne vérifie rien. Graph Paper ne vérifie le document que lorsque la personne ouvre le lien : la personne voit les erreurs, et vous ne les voyez pas. Un programme qui peut envoyer une requête doit d'abord envoyer le document à https://graph-paper.io/plot-link, et donner à la personne l'url de la réponse : il n'a alors rien à encoder. Construisez le lien vous-même seulement si aucune requête n'est possible, ou après une réponse "ok": true du service pour le même document.

Un exemple

Ce document trace une oscillation amortie, avec un curseur pour le coefficient d'amortissement c :

json{ "title": "Damped oscillation", "variables": [ { "name": "c", "value": "0.3", "domain": { "type": "range", "min": "0.05", "max": "1" }, "playback": { "mode": "bounce", "direction": "forward", "duration": 5000 }, "note": "The damping coefficient $c$. Drag the slider to change it." } ], "definitions": [{ "latex": "f(x) = e^{-c x} \\cos(6 x)", "hidden": true }], "series": [ { "type": "line", "fn": "f(x)", "domain": [0, 10] }, { "type": "line", "fn": "e^{-c x}", "domain": [0, 10], "stroke": { "dash": [4, 4] } } ], "domain": { "x": { "range": [0, 10] }, "y": { "range": [-1.2, 1.2] } } }

Pour l'encoder en JavaScript :

jsconst payload = btoa(String.fromCharCode(...new TextEncoder().encode(JSON.stringify(doc)))) .replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");

ou en Python :

pythonimport base64, json payload = base64.urlsafe_b64encode(json.dumps(doc).encode("utf-8")).decode("ascii").rstrip("=")

Le résultat :

Ouvrir ce document dans Graph Paper

Une surface 3D avec deux curseurs

Ce document trace un puits de gravité : le potentiel newtonien adouci z = -M / \sqrt{x^2 + y^2 + s^2}, avec un curseur pour la masse M et un curseur pour la longueur d'adoucissement s. Une série surface fait du document un tracé 3D.

json{ "title": "Gravity well (softened Newtonian potential)", "variables": [ { "name": "M", "value": "1", "domain": { "type": "range", "min": "0.1", "max": "3", "step": "0.1" }, "note": "Mass M (units with G = 1)" }, { "name": "s", "value": "0.4", "domain": { "type": "range", "min": "0.1", "max": "1.5", "step": "0.05" }, "note": "Softening length s" } ], "series": [ { "type": "surface", "fn": "-\\frac{M}{\\sqrt{x^2+y^2+s^2}}", "domain": { "x": [-4, 4], "y": [-4, 4] }, "color": "coolwarm", "wireframe": { "count": 24 } } ], "stage3d": { "environment": "paper" } }

Ouvrir ce document dans Graph Paper

Écrire un lien à la main

Un assistant sans aucun outil peut écrire un lien #json= : https://graph-paper.io/new#json= suivi du JSON du document, encodé en pourcentage. La règle : écrivez le JSON sur une seule ligne, puis encodez chaque caractère autre que les lettres A–Z et a–z, les chiffres 0–9 et -, _, ., ~ sous la forme % suivi des deux chiffres hexadécimaux de chacun de ses octets UTF-8. Par exemple une espace est %20, " est %22, \ est %5C (le LaTeX "\\sin(x)" du JSON devient donc %22%5C%5Csin%28x%29%22), + est %2B, ( est %28 et é est %C3%A9. Un lien encodé ainsi ne peut pas être changé par un moteur de rendu Markdown, qui peut retirer une barre oblique inverse.

Ce document trace une sinusoïde :

json{"title":"Sine wave","series":[{"type":"line","fn":"\\sin(x)"}]}

Le même document sous forme de lien :

https://graph-paper.io/new#json=%7B%22title%22%3A%22Sine%20wave%22%2C%22series%22%3A%5B%7B%22type%22%3A%22line%22%2C%22fn%22%3A%22%5C%5Csin%28x%29%22%7D%5D%7D

Ouvrir ce document dans Graph Paper

Rien ne vérifie un lien #json= avant que la personne l'ouvre. Si le document n'est pas valide, Graph Paper ouvre sa page d'accueil et affiche un message. Dites à la personne que vous n'avez pas pu vérifier le lien.

Si un lien ne peut pas atteindre la personne

Tout assistant qui écrit du texte peut écrire un lien #json=. Mais certaines applications coupent les liens longs, ou les modifient. Quand un lien ne peut pas atteindre la personne :

Donnez le document JSON à la personne. Dites-lui d'ouvrir un tracé dans Graph Paper, de cliquer sur le tracé et de coller le JSON. Graph Paper affiche un message avec l'action Ouvrir comme nouveau document, qui ouvre le document avec ses curseurs, ses notes et ses couleurs. Un texte JSON qui n'est pas un document valide n'est pas ouvert : le message dit que ce n'est pas un document de graphique.
En dernier recours, donnez à la personne des lignes à coller dans un nouveau tracé, à l'adresse https://graph-paper.io/new.

Écrivez ces lignes ainsi :

Une formule par ligne. La personne colle toutes les lignes en une fois dans la ligne vide, et chaque ligne devient une ligne du tracé.
Les mathématiques en texte simple sont lues : sqrt(x^2 + 1), x**2, 2*pi*x, abs(x), <=, les lettres grecques par leur nom (theta) ou comme lettres (θ). Une ligne entre $…$, ou une ligne avec une commande LaTeX comme \frac, est lue comme du LaTeX.
Le collage fonctionne aussi quand le tracé a le focus et qu'aucune ligne ne l'a. Les lignes vont alors après la dernière ligne.
Un commentaire après # devient une note : une ligne de texte au-dessus de sa ligne. Un commentaire après // devient aussi une note quand deux mots ou plus le suivent (// la masse). Après //, un seul mot ou une formule (x // 2) peut être une division d'un programme : la ligne reste alors du texte.
M = 1 crée une constante, pas un curseur. Pour un curseur, écrivez l'intervalle de la valeur : 0.1 <= M <= 3 ou M in [0.1, 3]. Le curseur démarre à sa plus petite valeur.
Une ligne que Graph Paper ne lit pas comme une formule reste du texte, mot pour mot, et le message après le collage la compte. Un nom inconnu de plusieurs lettres (mass, eps) n'est pas lu : utilisez une lettre ou une lettre grecque.
z = f(x, y) trace une surface 3D, et le tracé passe en 3D.

Le puits de gravité ci-dessus, sous forme de lignes :

0.1 <= M <= 3 // la masse 0.1 <= s <= 1.5 // adoucissement, pour que le centre n'aille pas à moins l'infini z = -M / sqrt(x^2 + y^2 + s^2)

Ces lignes ne fixent pas les valeurs de départ, les pas des curseurs, les couleurs ni la scène 3D du document.

Le format des documents

Le format des documents de tracé décrit chaque champ, chaque type de série et des exemples complets avec leurs liens. Les outils MCP get_plot_format et list_examples renvoient la même page (en anglais) et ses exemples. Pour ce qu'il faut écrire dans une formule, voir le Guide des tracés.

Chaque page de la Vitrine contient son document sous la même forme, dans une balise <script type="application/graph-paper+json" id="gallery-entry">. Servez-vous de la Vitrine pour apprendre par l'exemple.

Les carnets ont un autre format : le format de fichier des carnets (en anglais), avec des schémas JSON pour le fichier d'export et le contenu du carnet. Un lien /new ne peut pas ouvrir un carnet.

Lire sans compte

Le site. /llms.txt liste les pages principales et chaque entrée de la Vitrine. Chaque guide et chaque page de la Vitrine existe aussi en Markdown : ajoutez index.md à l'URL d'un guide (/plotting-guide/fr/index.md), ou .md à l'URL d'une entrée de la Vitrine. Vous pouvez aussi envoyer Accept: text/markdown avec la requête de l'URL de la page.

Les documents publics. Un document ou un dossier que son propriétaire a rendu public se lit par l'API à l'adresse https://graph-paper-api.still-meadow-cd52.workers.dev. L'identifiant est la dernière partie d'un lien de partage : https://graph-paper.io/d/<id> pour un document, https://graph-paper.io/f/<id> pour un dossier.

Requête	Renvoie
GET /api/documents/<id>	Les métadonnées et le contenu du document, en JSON.
GET /api/documents/<id>/content	Le contenu seul.
GET /api/documents/<id>/thumbnail	Une image d'aperçu (WebP, ou PNG).
GET /api/documents/<id>/seo-metadata	Le titre, la description et l'image de la page de partage.
GET /api/folders/<id>	Les métadonnées du dossier et la liste de ses éléments.
GET /api/folders/<id>/descendants	Une recherche dans les éléments du dossier, à tous les niveaux.

Par exemple :

shcurl https://graph-paper-api.still-meadow-cd52.workers.dev/api/documents/<id> curl https://graph-paper-api.still-meadow-cd52.workers.dev/api/documents/<id>/content curl -o preview.webp https://graph-paper-api.still-meadow-cd52.workers.dev/api/documents/<id>/thumbnail curl https://graph-paper-api.still-meadow-cd52.workers.dev/api/documents/<id>/seo-metadata curl https://graph-paper-api.still-meadow-cd52.workers.dev/api/folders/<id> curl https://graph-paper-api.still-meadow-cd52.workers.dev/api/folders/<id>/descendants

Le contenu enregistré est le format de stockage propre à l'application. Ce n'est pas le format des documents de tracé décrit plus haut.

Limites et erreurs :

Lectures de documents, de contenus et de dossiers : au plus 240 requêtes par minute depuis une même adresse IP. Recherches dans un dossier (descendants) : au plus 10 par minute. Au-delà, la réponse est 429 avec { "code": "RATE_LIMITED" }.
Un document qui n'est pas public, ou qui n'existe pas, renvoie 404. Un document protégé par un mot de passe renvoie 401.

Ce qui n'est pas possible

Pas d'API pour les documents d'une personne. Aucune API ne crée, ne modifie, n'enregistre ni ne lit les documents privés d'une personne. /plot-link et le serveur MCP ne font que vérifier un document et renvoyer un lien. Ils ne gardent rien et ne contiennent aucune donnée d'utilisateur. La personne enregistre le document à partir du lien.
Pas de clés d'API ni de jetons d'accès.
Pas d'enregistrement sans compte. La personne doit se connecter pour garder un document.
Pas d'intégration dans une autre page. Les pages de Graph Paper refusent de s'afficher dans un cadre (X-Frame-Options: DENY).
Pas d'export en image d'un document de tracé. La miniature d'un document public est la seule image que vous pouvez télécharger.

Outils dans l'onglet du navigateur

Graph Paper déclare cinq outils en lecture seule pour un agent qui s'exécute dans le même onglet du navigateur, par WebMCP. Ils sont désactivés par défaut : la personne connectée doit les activer, et ils n'agissent que sur le document ouvert ; voir /agent-tools.json. Ce ne sont pas les outils du serveur MCP situé à https://graph-paper.io/mcp.

Vérifier avant d'affirmer

/plot-link et make_plot_link vérifient le document : ses champs, leurs types et les limites. Ils ne tracent pas le tracé. Une formule en LaTeX valide peut quand même ne rien tracer. Avant de dire à une personne qu'un lien affiche un tracé, vérifiez les formules avec Quand une ligne ne trace rien dans le Guide des tracés.

Aucun service ne vous montre ce que Graph Paper trace. Dites à la personne que vous avez vérifié le document mais que vous n'avez pas vu le tracé, et préférez les formes de lignes que la page du format montre. Si vous n'avez pas pu vérifier le document, dites-le aussi.

Graph Paper vérifie les formules quand la personne ouvre le lien, et signale les lignes qui ne fonctionnent pas. Demandez ce rapport à la personne : voir Quand la personne ouvre le lien.