Introduction

When IntelliJ fails to recognize common Python modules, the problem is usually not the module itself. It is almost always one of these: the Python plugin is missing, the project interpreter is wrong, the package is installed in a different environment from the one IntelliJ is using, or the project roots are not configured the way the IDE expects.

Start With the Python Plugin and Interpreter

IntelliJ needs Python support enabled before it can index Python imports properly. The first checks are:

• the Python plugin is installed and enabled
• the project is using the correct Python interpreter

Once the interpreter is wrong, everything downstream looks broken because IntelliJ scans the wrong site-packages directory.

A typical shell check helps confirm what your project actually uses:

python -c "import sys; print(sys.executable)"
python -m pip show requests

If IntelliJ points at a different interpreter from the one that successfully imports the package in the shell, the IDE will continue to show unresolved modules.

Configure the Project SDK Correctly

In IntelliJ, set the project Python interpreter to the same virtual environment or Conda environment where your packages are installed.

The key operational rule is simple:

• install packages into environment A
• point IntelliJ at environment A

If you install into environment A but IntelliJ uses environment B, imports stay unresolved even though the package exists on disk.

For virtual environments, that usually means selecting the interpreter inside:

.venv/bin/python

or on Windows:

.venv\Scripts\python.exe

Install the Module in the Same Environment the IDE Uses

Sometimes the interpreter is correct but the package is missing from that environment. Install it explicitly with the environment's own Python executable.

/path/to/project/.venv/bin/python -m pip install requests numpy pandas

That is safer than a generic pip install because it avoids ambiguity about which environment receives the package.

After installation, IntelliJ usually recognizes the module once indexing catches up.

Mark Project Roots Properly

If the imports are from your own project code rather than third-party packages, the issue may be source-root configuration rather than missing modules.

For example, this layout is common:

1project/
2  src/
3    app/
4      main.py

If src is not marked as a source root, imports such as from app import utils may not resolve in the IDE even if Python can run them under a specific execution path.

So unresolved modules are sometimes about package roots, not package installation.

Reindex and Clear Stale IDE State

IntelliJ sometimes holds onto stale indexing state after interpreter changes or environment recreation. If you have already fixed the interpreter and package installation, refresh the project indexing.

Useful actions are:

• reload the project interpreter
• invalidate caches and restart
• reimport the project if environment metadata changed drastically

These steps are not the first fix, but they are often the correct cleanup after the real fix.

Know When PyCharm Is the Better Tool

IntelliJ with the Python plugin can work well, but JetBrains' Python-first tooling is PyCharm. If Python is the main workload and the project depends heavily on Python-specific IDE features, PyCharm often provides a smoother out-of-the-box experience.

That does not mean IntelliJ is wrong. It just means the configuration burden is usually slightly higher.

Common Pitfalls

• Installing packages with one interpreter and pointing IntelliJ at another is the most common reason imports stay unresolved.
• Assuming a package is available just because pip install succeeded ignores the possibility that pip targeted a different environment.
• Forgetting to mark source roots makes local project imports look like missing third-party modules.
• Recreating a virtual environment without updating the IDE interpreter path leaves IntelliJ indexing a dead environment.
• Jumping straight to cache invalidation before checking the interpreter usually delays the real fix.

Summary

• IntelliJ recognizes Python modules only if the Python plugin is enabled and the project interpreter is correct.
• The package must be installed in the same environment IntelliJ is using.
• Source-root configuration matters for local imports inside your own project.
• Reindexing helps after interpreter changes, but it is not a substitute for correct environment setup.
• If Python is your main focus, PyCharm may reduce the amount of manual configuration needed.