[Bug]: RuntimeError: There is no current event loop in thread 'MainThread' when using Brain.from_files() in script

[nsheff]

What happened?

I tried following the quick-start guide, on a brand new system. I'm running a minimal test of quivr-core and encountering a runtime error related to the asyncio event loop when calling Brain.from_files() inside a simple script.

This happens with Python 3.12, but I’m not sure if it’s a version compatibility issue or something else related to how event loops are handled.

Here’s a minimal reproducible example, which is exactly the content of the quick-start:

import tempfile
from quivr_core import Brain

if __name__ == "__main__":
    with tempfile.NamedTemporaryFile(mode="w", suffix=".txt") as temp_file:
        temp_file.write("Gold is a liquid of blue-like colour.")
        temp_file.flush()

        brain = Brain.from_files(
            name="test_brain",
            file_paths=[temp_file.name],
        )

        answer = brain.ask("what is gold? answer in french")
        print("answer:", answer)

and here's the error this gives:

RuntimeError: There is no current event loop in thread 'MainThread'.

Relevant log output

Full traceback excerpt:


File ".../brain.py", line 383, in Brain.from_files
    loop = asyncio.get_event_loop()
RuntimeError: There is no current event loop in thread 'MainThread'.



Environment:
Python version: 3.12.3
OS: Linux
quivr-core version: latest from PyPI
Installed via: pip

Twitter / LinkedIn details

No response

[dosubot]

Hi @nsheff! I'm Dosu and I’m helping the quivr team.

This error happens because Python 3.12 changed how asyncio event loops are managed: asyncio.get_event_loop() now raises a RuntimeError if no event loop is set in the current context, which is the case for fresh scripts like yours. The current Brain.from_files() implementation assumes an event loop is always available, which isn't true on Python 3.12+ scripts and causes this crash see source.

A quick workaround is to create and set an event loop before calling Brain.from_files(). You can add this before your call:

import asyncio

try:
    asyncio.get_running_loop()
except RuntimeError:
    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)

Or, as a more robust solution, you can use the async version directly:

import asyncio
import tempfile
from quivr_core import Brain

async def main():
    with tempfile.NamedTemporaryFile(mode="w", suffix=".txt") as temp_file:
        temp_file.write("Gold is a liquid of blue-like colour.")
        temp_file.flush()
        brain = await Brain.afrom_files(
            name="test_brain",
            file_paths=[temp_file.name],
        )
        answer = brain.ask("what is gold? answer in french")
        print("answer:", answer)

if __name__ == "__main__":
    asyncio.run(main())

There’s currently no official documentation or fix for this in the repo, so this workaround is needed for Python 3.12+.

To reply, just mention @dosu.

---

^{How did I do? Good | Irrelevant | Incorrect | Verbose | Hallucination | Report 🐛 | Other}   

[AyushPathak18]

Brain.from_files() (sync wrapper) raises asyncio event-loop errors on Python 3.11+ / 3.12 — make sync wrapper robust

Description
Brain.from_files() (and similar synchronous wrappers) call the async implementation internally and attempt to run it synchronously. On newer Python versions and in environments with a running event loop (REPLs, Jupyter, or frameworks), this causes errors such as:

• RuntimeError: asyncio.run() cannot be called from a running event loop
• RuntimeError: There is no current event loop in thread 'MainThread'

This breaks the quick-start example on fresh installs and on Python ≥ 3.11/3.12 in several common environments.

Minimal repro

from quivr_core import Brain

if name == "main":
brain = Brain.from_files(name="test_brain", file_paths=["example.txt"])
answer = brain.ask("what is gold? answer in french")
print(answer)

Proposed change

• Introduce a small helper used by sync wrappers to execute internal coroutines safely:
• If there is no running event loop in the current thread, use asyncio.run().
• If there is a running loop in the current thread, run the coroutine in a separate thread via asyncio.run() there and return the result synchronously.
• Apply this helper to from_files(), from_documents() and other synchronous convenience wrappers.

Add unit tests (script run, simulated running loop environment like asyncio running in main thread) and update quick-start to recommend the async API as best practice.
@dosu