Rules

You have two keys, and the order matters. The shared hackathon key comes first: it carried 24 simultaneous requests in testing without a single failure. Your team key is the fallback, good for about six at once, and it exists so you are never stuck.

Retry once if a request is refused. A 429 means too many at the same instant, not that anything is broken. In testing every refused request worked when sent again. Press send again, or catch it in code. Sending requests one after another rather than all at once avoids it entirely.

Your key is an EPFL credential, and you are responsible for what is done with it. It is issued against a real EPFL account, and every request made with it is attributed to that account. A key that ends up in a public repository is found by automated scanners within hours and used by strangers. EPFL can suspend access without notice. Leaking the shared key takes the service down for every team at once, which is precisely why you also have your own. Keep it in a .env file, add .env to your .gitignore, and never put it in a commit, a screenshot, a slide or a shared document. Every key is deleted on Sunday evening.

No personal data about identifiable people.

Start here

Are you an EPFL employee, or an EPFL student working in a lab?

base_url = "https://inference-rcp.epfl.ch/v1"
api_key  = "your own key"

The controls

Models

Small answers in a second or two and handles ordinary work. Big is slower because it thinks first, and is better at hard reasoning. Start small, switch up when the answer is not good enough.

Reach for DeepSeek, GLM or Apertus: all three are recommended and all three will carry your project. DeepSeek and GLM are EPFL's own picks, "the best ranked Open Weights models at one point in time". Apertus is the open Swiss model built at EPFL with ETH Zurich and handles the same work well, with open weights, open data and an open training recipe, in two sizes: 70B for the hard questions and 8B when you want an answer quickly. You can do the whole hackathon on any of the three.

The endpoint serves more than these seven, which are more than enough for the weekend. The two others worth knowing about are Qwen/Qwen3-Embedding-8B for embeddings and BAAI/bge-reranker-v2-m3 for reranking, both explained under Your own code. To see the full list, which comes back as raw JSON:

curl https://inference-rcp.epfl.ch/v1/models -H "Authorization: Bearer YOUR_KEY"

Web search

Off until you turn it on. Diamond icon, bottom left of the message box.

What changes when you do:

• Your search terms leave EPFL and go to an outside search engine. Your documents do not, but the words used to search them do.
• The answer can draw on pages found on the web, instead of only on what the model already knows.
• It is slower and uses more of your team's share.

Turn it off as soon as you are done. It stays on until you switch it back off, so every message after it keeps sending your words outside EPFL and keeps costing your team extra. Use it only when you actually need a source.

If it breaks

Your own code

This section is for running inference from your own project code, rather than through the chat.

The service works the same way as OpenAI's, so any library written for OpenAI works here too. You change two things, the address and the key, and the rest of your code is unchanged.

Works from anywhere, no EPFL account and no EPFL wifi. Watch the hyphen: inference-rcp. The version with a dot is EPFL-internal and will not resolve off campus.

Use the shared hackathon key first, and fall back to your team key. The shared one is far larger: 24 requests at once with no failures in testing, against about six for a team key. Both are in your profile.

Python

from openai import OpenAI

SHARED = "sk-..."   # the hackathon key, use this first
TEAM   = "sk-..."   # your team key, the fallback

def ask(messages, model="deepseek-ai/DeepSeek-V4-Flash-0731"):
    last = None
    for key in (SHARED, TEAM):
        client = OpenAI(base_url="https://inference-rcp.epfl.ch/v1", api_key=key)
        try:
            return client.chat.completions.create(model=model, messages=messages)
        except Exception as e:
            last = e            # busy, refused, or blocked: try the other key
    raise last

r = ask([{"role": "user", "content": "Hello"}])
print(r.choices[0].message.content)

That pattern costs four lines and covers the three things that go wrong: the shared key busy, the shared key blocked, or a transient failure. If you would rather keep it simple, use the shared key alone and keep your team key in your pocket.

Retrieval: embeddings and reranking

Two models for building retrieval-augmented generation over your own corpus. Neither is exposed in the chat, only through the API.

Computing embeddings

e = client.embeddings.create(
    model="Qwen/Qwen3-Embedding-8B",
    input=["first document", "second document"],
)
vectors = [d.embedding for d in e.data]   # dim 4096

Reranking candidates

import requests

r = requests.post(
    "https://inference-rcp.epfl.ch/v1/rerank",
    headers={"Authorization": "Bearer YOUR_KEY"},
    json={
        "model": "BAAI/bge-reranker-v2-m3",
        "query": "how do rumours spread",
        "documents": ["Cats are mammals.",
                      "False claims spread faster than corrections.",
                      "The weather is cold."],
        "top_n": 2,
    },
)
print(r.json()["results"])   # sorted by relevance_score, descending

Tools more at wiki.rcp.epfl.ch

These are ready-made programs that can run on EPFL's models instead of a paid provider. You install them, paste in the address and your key, and they work. No code needed.

They fall into four kinds:

• Coding agents. They live in your editor or terminal, read your project's files and write or fix code for you, rather than you copying text in and out of a chat window.
• Desktop chat apps. A chat window installed on your own machine instead of a website. AnythingLLM also answers questions about a folder of your own documents.
• Transcription. Turns audio or video into text, useful if your challenge involves recordings.
• Workflow builders. Drag-and-drop tools for chaining several steps together, for a team that wants a pipeline rather than a script.

All of them take the same three settings: the address, your key, and a model name. The list comes from EPFL's own page of tools tested against the service, which has many more and their full configuration. It only opens on the EPFL network or eduroam, and its examples use the internal address, so use the external one instead.

VS Code

Base URL   https://inference-rcp.epfl.ch/v1
API key    your key
Model      moonshotai/Kimi-K2.7-Code

Claude Code is the exception. RCP documents it, but it speaks a different protocol and that route only exists on EPFL's internal address. I tested it against the external one: it answers 404, so it does not work from outside the campus network. Use one of the tools above instead.

Links

• Our chatanywhere
• Create your own EPFL keyEPFL network, eduroam or VPN
• EPFL's own chatEPFL network or eduroam
• RCP wiki, tool setupEPFL network or eduroam
• About the serviceanywhere
• PeaceTech Hackathonanywhere