LLM4S provides a simple, robust, and scalable framework for building LLM applications in Scala. While most LLM work is done in Python, we believe that Scala offers a fundamentally better foundation for building reliable, maintainable AI-powered applications.

Note: This is a work in progress project and is likely to change significantly over time.

• Type Safety: Catch errors at compile time, not in production.
• Functional Programming: Immutable data and pure functions for predictable, maintainable systems.
• JVM Ecosystem: Access to mature, production-grade libraries and tooling.
• Concurrency: Advanced models for safe, efficient parallelism.
• Performance: JVM speed with functional elegance.
• Ecosystem Interoperability: Seamless integration with enterprise JVM systems and cloud-native tooling.

• Multi-Provider Support: Connect seamlessly to multiple LLM providers (OpenAI, Anthropic, Google Gemini, Azure, Ollama, DeepSeek).
• Execution Environments: Run LLM-driven operations in secure, containerized or non-containerized setups.
• Error Handling: Robust mechanisms to catch, log, and recover from failures gracefully.
• MCP Support: Integration with Model Context Protocol for richer context management.
• Agent Framework: Build single or multi-agent workflows with standardized interfaces.
• Multimodal Generation: Support for text, image, voice, and other LLM modalities.
• RAG (Retrieval-Augmented Generation): Built-in tools for search, embedding, retrieval workflows, and RAGAS evaluation with benchmarking harness.
• Observability: Detailed trace logging, monitoring, and analytics for debugging and performance insights.

        ┌───────────────────────────┐
        │    LLM4S API Layer        │
        └──────────┬────────────────┘
                   │
          Multi-Provider Connector
        (OpenAI | Anthropic | DeepSeek | ...)
                   │
         ┌─────────┴─────────┐
         │ Execution Manager │
         └─────────┬─────────┘
                   │
        ┌──────────┴──────────┐
        │   Agent Framework   │
        └──────────┬──────────┘
                   │
      ┌────────────┴────────────┐
      │  RAG Engine + Tooling   │
      └────────────┬────────────┘
                   │
     ┌─────────────┴─────────────┐
     │   Observability Layer     │
     └───────────────────────────┘

• modules/core: Core LLM4S framework
• modules/workspace: Workspace runner/client/shared
• modules/crossTest: Cross-version tests
• modules/samples: Usage examples
• docs: Documentation site and references
• hooks: Pre-commit hook installer

To get started with the LLM4S project, check out this teaser talk presented by Kannupriya Kalra at the Bay Area Scala Conference. This recording is essential for understanding where we’re headed:

🎥 Teaser Talk: https://www.youtube.com/watch?v=SXybj2P3_DE&ab_channel=SalarRahmanian

LLM4S was officially introduced at the Bay Area Scala Conference in San Francisco on February 25, 2025.

To ensure code quality, we use a Git pre-commit hook that automatically checks code formatting and runs tests before allowing commits:

# Install the pre-commit hook
./hooks/install.sh

# The hook will automatically:
# - Check code formatting with scalafmt
# - Compile code for both Scala 2.13 and 3
# - Run tests for both Scala versions

# To skip the hook temporarily (not recommended):
# git commit --no-verify

• JDK 21+
• SBT
• Docker

java -version

Set JAVA_HOME and update your PATH.

brew install openjdk@21
echo 'export PATH="/opt/homebrew/opt/openjdk@21/bin:$PATH"' >> ~/.zshrc

sbt compile

# For all supported Scala versions (2.13 and 3)
sbt +compile

# Build and test all versions
sbt buildAll

See: docs/reference/contributing.md#IDE-Setup

You will need an API key for either OpenAI (https://platform.openai.com/) or Anthropic (https://console.anthropic.com/) other LLMS may be supported in the future (see the backlog).

Set the environment variables:

LLM_MODEL=openai/gpt-4o
OPENAI_API_KEY=<your_openai_api_key>

or Anthropic:

LLM_MODEL=anthropic/claude-sonnet-4-5-latest
ANTHROPIC_API_KEY=<your_anthropic_api_key>

or OpenRouter:

LLM_MODEL=openai/gpt-4o
OPENAI_API_KEY=<your_openai_api_key>
OPENAI_BASE_URL=https://openrouter.ai/api/v1

or Z.ai:

LLM_MODEL=zai/GLM-4.7
ZAI_API_KEY=<your_zai_api_key>
ZAI_BASE_URL=https://api.z.ai/api/paas/v4

or DeepSeek:

LLM_MODEL=deepseek/deepseek-chat
DEEPSEEK_API_KEY=<your_deepseek_api_key>
# Optional: DEEPSEEK_BASE_URL defaults to https://api.deepseek.com

Migration Note: The LLMProvider.DeepSeek case has been added to the sealed LLMProvider ADT. If you have exhaustive pattern matches on LLMProvider, add a case LLMProvider.DeepSeek => ... handler, or use a wildcard case _ => ... to gracefully handle future providers.

Or Cohere:

LLM_MODEL=cohere/command-r
COHERE_API_KEY=<your_cohere_api_key>
COHERE_BASE_URL=https://api.cohere.com

This will allow you to run the non-containerized examples.

# Using Scala 3
sbt "samples/runMain org.llm4s.samples.basic.BasicLLMCallingExample"

sbt docker:publishLocal
sbt "workspaceSamples/runMain org.llm4s.samples.workspace.ContainerisedWorkspaceDemo"

# Using Scala 2.13
sbt ++2.13.16 "samples/runMain org.llm4s.samples.basic.BasicLLMCallingExample"

LLM4S supports Scala 2.13 and Scala 3.7.1. The build supports version-specific code through source directories when needed:

• src/main/scala - Common code for all versions
• src/main/scala-2.13 - Scala 2.13 specific code (add when needed)
• src/main/scala-3 - Scala 3 specific code (add when needed)

When you need to use version-specific features, place the code in the appropriate directory.

We've added convenient aliases for cross-compilation:

# Compile for all Scala versions
sbt compileAll

# Test all Scala versions
sbt testAll

# Both compile and test
sbt buildAll

# Publish for all versions
sbt publishAll

We use specialized test projects to verify cross-version compatibility against the published artifacts. These tests ensure that the library works correctly across different Scala versions by testing against actual published JARs rather than local target directories.

# Run tests for both Scala 2 and 3 against published JARs
sbt testCross

# Full clean, publish, and test verification
sbt fullCrossTest

Note: For detailed information about our cross-testing strategy and setup, see modules/crossTest/README.md

Our goal is to implement Scala equivalents of popular Python LLM frameworks, with multi-provider, multimodal, and observability-first design as core principles.

For the full roadmap including core framework features and agent phases, see the LLM4S Roadmap

The roadmap covers:

• Core Framework Features: Multi-provider LLM, image generation, speech, embeddings, tools, MCP
• Agent Framework Phases: Conversations, guardrails, handoffs, memory, streaming, built-in tools
• Production Pillars: Testing, API Stability, Performance, Security, Documentation, Observability
• Path to v1.0.0: Structured path to production release

• [ ] Single API access to multiple LLM providers (like LiteLLM) - llmconnect ✅ Complete
• [ ] Comprehensive toolchain for building LLM apps (LangChain/LangGraph equivalent)
  • [x] Tool calling ✅ Complete
  • [x] RAG search & retrieval ✅ Complete (vector memory, embeddings, document Q&A)
  • [x] RAG evaluation & benchmarking ✅ Complete (RAGAS metrics, systematic comparison)
  • [x] Logging, tracking, and monitoring ✅ Complete
• [ ] Agentic framework (like PydanticAI, CrewAI)
  • [x] Single-agent workflows ✅ Complete
  • [x] Multi-agent handoffs ✅ Complete
  • [x] Memory system (in-memory, SQLite, vector) ✅ Complete
  • [x] Streaming events ✅ Complete
  • [x] Built-in tools module ✅ Complete
  • [ ] DAG-based orchestration 🚧 In Progress
• [ ] Tokenization utilities (Scala port of tiktoken) ✅ Complete
• [ ] Examples for all supported modalities and workflows ✅ Complete
• [ ] Stable platform with extensive test coverage 🚧 In Progress
• [ ] Scala Coding SWE Agent - perform SWE Bench–type tasks on Scala codebases
  • [ ] Code maps, code generation, and library templates

Tool calling is a critical integration - designed to work seamlessly with multi-provider support and agent frameworks. We use ScalaMeta to auto-generate tool definitions, support dynamic mapping, and run in secure execution environments.

Tools can run:

• In containerized sandboxes for isolation and safety.
• In multi-modal pipelines where LLMs interact with text, images, and voice.
• With observability hooks for trace analysis.

Using ScalaMeta to automatically generate tool definitions from Scala methods:

/** My tool does some funky things with a & b...
 * @param a The first thing
 * @param b The second thing
 */
def myTool(a: Int, b: String): ToolResponse = {
  // Implementation
}

ScalaMeta extracts method parameters, types, and documentation to generate OpenAI-compatible tool definitions.

Mapping LLM tool call requests to actual method invocations through:

• Code generation
• Reflection-based approaches
• ScalaMeta-based parameter mapping

Tools run in a protected Docker container environment to prevent accidental system damage or data leakage.

Tracing isn’t just for debugging - it’s the backbone of understanding model behavior.LLM4S’s observability layer includes:

• Detailed token usage reporting
• Multi-backend trace output (Langfuse, console, none)
• Agent state visualization
• Integration with monitoring dashboards

Configure tracing behavior using the TRACING_MODE environment variable:

# Send traces to Langfuse (default)
TRACING_MODE=langfuse
LANGFUSE_PUBLIC_KEY=pk-lf-your-key
LANGFUSE_SECRET_KEY=sk-lf-your-secret

# Print detailed traces to console with colors and token usage
TRACING_MODE=print

# Disable tracing completely
TRACING_MODE=none

import org.llm4s.trace.{ EnhancedTracing, Tracing }

// Create tracer from environment (Result), fallback to console tracer
val tracer: Tracing = EnhancedTracing
  .createFromEnv()
  .fold(_ => Tracing.createFromEnhanced(new org.llm4s.trace.EnhancedConsoleTracing()), Tracing.createFromEnhanced)

// Trace events, completions, and token usage
tracer.traceEvent("Starting LLM operation")
tracer.traceCompletion(completion, completion.model) // prefer the model reported by the API
tracer.traceTokenUsage(tokenUsage, completion.model, "chat-completion")
tracer.traceAgentState(agentState)

Note: The LLM4S template has moved to its own repository for better maintainability and independent versioning.

The llm4s.g8 starter kit helps you quickly create AI-powered applications using llm4s. It is a starter kit for building AI-powered applications using llm4s with improved SDK usability and developer ergonomics. You can now spin up a fully working scala project with a single sbt command. The starter kit comes pre-configured with best practices, prompt execution examples, CI, formatting hooks, unit testing, documentation, and cross-platform support.

Template Repository: github.com/llm4s/llm4s.g8

Using sbt, do:

sbt new llm4s/llm4s.g8 \
--name=<your.project.name> \
--package=<your.organization> \
--version=0.1.0-SNAPSHOT \
--llm4s_version=<llm4s.version> \ # 0.1.1 is the latest version at the time of writing
--scala_version=<scala.version> \ # 2.x.x or Scala 3.x.x
--munit_version=<munit.version> \ # 1.1.1 is the latest version at the time of writing
--directory=<your.project.name> \
--force

to create new project.

For more information about the template, including compatibility matrix and documentation, visit the template repository. Use the comprehensive documentation to get started with the project using starter kit.

llm4s exposes a single configuration flow with sensible precedence:

• Precedence: -D system properties > application.conf (if your app provides it) > reference.conf defaults.
• Environment variables are wired via ${?ENV} in reference.conf (no .env reader required).

Preferred typed entry points (PureConfig-backed via Llm4sConfig):

• Provider / model:
  • Llm4sConfig.provider(): Result[ProviderConfig] – returns the typed provider config (OpenAI/Azure/Anthropic/Ollama).
  • LLMConnect.getClient(config: ProviderConfig): Result[LLMClient] – builds a client from a typed config.
• Tracing:
  • Llm4sConfig.tracing(): Result[TracingSettings] – returns typed tracing settings.
  • EnhancedTracing.create(settings: TracingSettings): EnhancedTracing – builds an enhanced tracer from typed settings.
  • Tracing.create(settings: TracingSettings): Tracing – builds a legacy Tracing from typed settings.
• Embeddings:
  • Llm4sConfig.embeddings(): Result[(String, EmbeddingProviderConfig)] – returns (provider, config) with validation.
  • EmbeddingClient.from(provider: String, cfg: EmbeddingProviderConfig): Result[EmbeddingClient] – builds an embeddings client from typed config.

Recommended usage patterns:

• Model name for display: Llm4sConfig.provider().map(_.model) or prefer completion.model from API responses.
• Tracing:
  • For enhanced tracing: Llm4sConfig.tracing().map(EnhancedTracing.create).
  • For legacy Tracing: Llm4sConfig.tracing().map(Tracing.create).
• Workspace (samples): WorkspaceConfigSupport.load() to get workspaceDir, imageName, hostPort, traceLogPath.
• Embeddings sample (samples): EmbeddingUiSettings.loadFromEnv, EmbeddingTargets.loadFromEnv, EmbeddingQuery.loadFromEnv (sample helpers backed by Llm4sConfig).

Use these loaders to convert flat keys and HOCON paths into typed, validated settings used by the code:

• LLM model selection

  • Keys: llm4s.llm.model or LLM_MODEL
  • Type: ProviderConfig (with provider-specific subtypes)
  • Loader: Llm4sConfig.provider() + LLMConnect.getClient(...)

• Tracing configuration

  • Keys: llm4s.tracing.mode | TRACING_MODE, LANGFUSE_URL, LANGFUSE_PUBLIC_KEY, LANGFUSE_SECRET_KEY, LANGFUSE_ENV, LANGFUSE_RELEASE, LANGFUSE_VERSION
  • Type: TracingSettings
  • Loader: Llm4sConfig.tracing() → then EnhancedTracing.create or Tracing.create

• Workspace settings (samples)

  • Keys: llm4s.workspace.dir | WORKSPACE_DIR, llm4s.workspace.image | WORKSPACE_IMAGE, llm4s.workspace.port | WORKSPACE_PORT, llm4s.workspace.traceLogPath | WORKSPACE_TRACE_LOG
  • Type: WorkspaceSettings
  • Loader: WorkspaceConfigSupport.load()

• Embeddings: inputs and UI (samples)

  • Input paths: EMBEDDING_INPUT_PATHS or EMBEDDING_INPUT_PATH → EmbeddingTargets.loadFromEnv() → EmbeddingTargets
  • Query: EMBEDDING_QUERY → EmbeddingQuery.loadFromEnv() → EmbeddingQuery
  • UI knobs: MAX_ROWS_PER_FILE, TOP_DIMS_PER_ROW, GLOBAL_TOPK, SHOW_GLOBAL_TOP, COLOR, TABLE_WIDTH → EmbeddingUiSettings.loadFromEnv() → EmbeddingUiSettings

• Embeddings: provider configuration

  • Key: EMBEDDING_PROVIDER or llm4s.embeddings.provider (required)
  • Supported providers: openai, voyage, ollama
  • Type: (String, EmbeddingProviderConfig)
  • Loader: Llm4sConfig.embeddings()
  • Provider-specific keys:
    • OpenAI: OPENAI_EMBEDDING_BASE_URL, OPENAI_EMBEDDING_MODEL, OPENAI_API_KEY
    • Voyage: VOYAGE_EMBEDDING_BASE_URL, VOYAGE_EMBEDDING_MODEL, VOYAGE_API_KEY
    • Ollama (local): OLLAMA_EMBEDDING_BASE_URL (default: http://localhost:11434), OLLAMA_EMBEDDING_MODEL

• Provider API keys and endpoints

  • Keys: OPENAI_API_KEY, OPENAI_BASE_URL, ANTHROPIC_API_KEY, ANTHROPIC_BASE_URL, AZURE_API_BASE, AZURE_API_KEY, AZURE_API_VERSION, OLLAMA_BASE_URL, GEMINI_BASE_URL, GOOGLE_API_KEY, DEEPSEEK_API_KEY, DEEPSEEK_BASE_URL, COHERE_BASE_URL, COHERE_API_KEY
  • Type: concrete ProviderConfig (e.g., OpenAIConfig, AnthropicConfig, AzureConfig, OllamaConfig, GeminiConfig, DeepSeekConfig, CohereConfig)
  • Loader: Llm4sConfig.provider() → then provider-specific config constructors

Tracing

• Configure mode via llm4s.tracing.mode (default: console). Supported: langfuse, console, noop.
• Override with env: TRACING_MODE=langfuse (or system property -Dllm4s.tracing.mode=langfuse).
• Build tracers:
  • Typed: Llm4sConfig.tracing().map(EnhancedTracing.create) → Result[EnhancedTracing]
  • Legacy bridge: Llm4sConfig.tracing().map(Tracing.create)
  • Low-level: LangfuseTracing.fromEnv() → Result[LangfuseTracing]

Example (no application.conf required):

sbt -Dllm4s.llm.model=openai/gpt-4o -Dllm4s.openai.apiKey=sk-... "samples/runMain org.llm4s.samples.basic.BasicLLMCallingExample"

Or with environment variables (picked up via reference.conf):

export LLM_MODEL=openai/gpt-4o
export OPENAI_API_KEY=sk-...
sbt "samples/runMain org.llm4s.samples.basic.BasicLLMCallingExample"

LLM4S uses GitHub Actions for continuous integration to ensure code quality and compatibility across different platforms and Scala versions.

Our unified CI workflow runs on every push and pull request to main/master branches:

• Quick Checks: Fast-failing checks for code formatting and compilation
• Cross-Platform Testing: Tests run on Ubuntu and Windows with Scala 2.13.16 and 3.7.1
• Template Validation: Verifies the g8 template works correctly
• Caching: Optimized caching strategy with Coursier for faster builds

Automated AI-powered code review for pull requests:

• Automatic Reviews: Trusted PRs get automatic Claude reviews
• Security: External PRs require manual trigger by maintainers
• Manual Trigger: Maintainers can request reviews with @claude comment

Automated release process triggered by version tags (format: v0.1.11):

• Tag Format: Must use v prefix (e.g., v0.1.11, not 0.1.11)
• Pre-release Checks: Runs full CI suite before publishing
• GPG Signing: Artifacts are signed for security
• Maven Central: Publishes to Sonatype/Maven Central

See RELEASE.md for detailed release instructions.

You can run the same checks locally before pushing:

# Check formatting
sbt scalafmtCheckAll

# Compile all Scala versions
sbt +compile

# Run all tests
sbt +test

# Full build (compile + test)
sbt buildAll

Stay hands-on with LLM4S! Join us for interactive mob programming sessions, live debugging, and open-source collaboration. These events are great for developers, contributors, and anyone curious about Scala + GenAI.

🗓️ Weekly live coding and collaboration during LLM4S Dev Hour, join us every Sunday on Discord!

See the talks being given by maintainers and open source developers globally and witness the engagement by developers around the world.

Stay updated with talks, workshops, and presentations about LLM4S happening globally. These sessions dive into the architecture, features, and future plans of the project.

Snapshots from LLM4S talks held around the world 🌍.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |

| 12-18-Oct-2025 | ICFP/SPLASH 2025 (The Scala Workshop 2025) | Mentoring in the Scala Ecosystem: Insights from Google Summer of Code | Peony West, Marina Bay Sands Convention Center, Singapore 🇸🇬 | Kannupriya Kalra | ICFP/SPLASH 2025 Event Website , The Scala Workshop 2025 Schedule , LinkedIn Post , X/Twitter Post , Mastodon Post , Bluesky Post , Reddit Discussion | Watch Recording | – | 24-Oct-2025 | GEN AI London 2025 | Building Reliable AI systems: From Hype to Practical Toolkits | Queen Elizabeth II Center in the City of Westminster, London, UK 🇬🇧 | Kannupriya Kalra | GEN AI London Event Website , GEN AI London 2025 Schedule , LinkedIn Post 1 , LinkedIn Post 2 , LinkedIn Post 3 , X/Twitter Post , Mastodon Post , Bluesky Post , Reddit Discussion | Recording will be posted once the event is done, View Slides, Download Slides | – |

======= | 18-Sept-2025 | Scala Center Talks | Lightning Talks Powered by GSoC 2025 for Scala | EPFL campus, Lausanne, Switzerland 🇨🇭 | Kannupriya Kalra | Event Invite , LinkedIn Post , Scala Center's LinkedIn Post , X/Twitter Post , Mastodon Post , Bluesky Post , Reddit Discussion | Recording will be posted once the event is done, View LLM4S Slides 1, 2, 3, 4, Download LLM4S Slides 1, 2, 3, 4 | – | | 12-18-Oct-2025 | ICFP/SPLASH 2025 (The Scala Workshop 2025) | Mentoring in the Scala Ecosystem: Insights from Google Summer of Code | Peony West, Marina Bay Sands Convention Center, Singapore 🇸🇬 | Kannupriya Kalra | ICFP/SPLASH 2025 Event Website , The Scala Workshop 2025 Schedule , LinkedIn Post , X/Twitter Post , Mastodon Post , Bluesky Post , Reddit Discussion | Watch Recording | – | | 24-Oct-2025 | GEN AI London 2025 | Building Reliable AI systems: From Hype to Practical Toolkits | Queen Elizabeth II Center in the City of Westminster, London, UK 🇬🇧 | Kannupriya Kalra | GEN AI London Event Website , GEN AI London 2025 Schedule , LinkedIn Post 1 , LinkedIn Post 2 , LinkedIn Post 3 , X/Twitter Post , Mastodon Post , Bluesky Post , Reddit Discussion | Recording will be posted once the event is done, View Slides, Download Slides | – |

b0eede0 (docs(readme): fix markdown table row to render correctly) | 23-25-Oct-2025 | Google Summer Of Code Mentor Summit 2025 | LLM4S x GSoC 2025: Engineering GenAI Agents in Functional Scala | Google Office, Munich, Erika-Mann-Str. 33 · 80636 München, Germany 🇩🇪 | Kannupriya Kalra | Event Website | Recording will be posted once the event is done. View Scala Center Slides, Download Scala Center Slides, View GSoC Mentor Summit All Speakers Slides, Download GSoC Mentor Summit All Speakers Slides | – | | 29-30-Nov-2025 | Oaisys Conf 2025: AI Practitioners Conference | LLM4S: Building Reliable AI Systems in the JVM Ecosystem | MCCIA, Pune, India 🇮🇳 | Kannupriya Kalra, Shubham Vishwakarma | Event Website, LinkedIn Post, X/Twitter Post, Mastodon Post, Bluesky Post, Reddit Post | Recording will be posted once the event recordings are available. View Slides, Download Slides | – | | 10-Dec-2025 |AI Compute & Hardware Conference 2025 | Functional Intelligence: Building Scalable AI Systems for the Hardware Era | Samsung HQ, San Jose, California, USA 🇺🇸 | Kannupriya Kalra | Event Website, Event details on Meetup, LinkedIn Post, X/Twitter Post, Mastodon Post, Bluesky Post, Reddit Post | Recording will be posted once the event recordings are available. View Slides (coming soon), Download Slides (coming soon) | – |

📝 Want to invite us for a talk or workshop? Reach out via our respective emails or connect on Discord: https://discord.gg/4uvTPn6qww

• Build AI-powered applications in a statically typed, functional language designed for large systems.
• Help shape the Scala ecosystem’s future in the AI/LLM space.
• Learn modern LLM techniques like zero-shot prompting, tool calling, and agentic workflows.
• Collaborate with experienced Scala engineers and open-source contributors.
• Gain real-world experience working with Dockerized environments and multi-LLM providers.
• Contribute to a project that offers you the opportunity to become a mentor or contributor funded by Google through its Google Summer of Code (GSoC) program.
• Join a global developer community focused on type-safe, maintainable AI systems.

Interested in contributing? Start here:

LLM4S GitHub Issues: https://lnkd.in/eXrhwgWY

Want to be part of developing this and interact with other developers? Join our Discord community!

LLM4S Discord: https://lnkd.in/eb4ZFdtG

LLM4S was selected for GSoC 2025 under the Scala Center Organisation.

This project is also participating in Google Summer of Code (GSoC) 2025! If you're interested in contributing to the project as a contributor, check out the details here:

👉 Scala Center GSoC Ideas: https://lnkd.in/enXAepQ3

To know everything about GSoC and how it works, check out this talk:

🎥 GSoC Process Explained: https://lnkd.in/e_dM57bZ

To learn about the experience of GSoC contributors of LLM4S, check out their blogs in the section below.

📚 Explore Past GSoC Projects with Scala Center: https://www.gsocorganizations.dev/organization/scala-center/ This page includes detailed information on all GSoC projects with Scala Center from past years - including project descriptions, code repositories, contributor blogs, and mentor details.

Hello GSoCers and future GSoC aspirants! Here are some essential onboarding links to help you collaborate and stay organized within the LLM4S community.

• 🔗 LLM4S GSoC GitHub Team:You have been invited to join the LLM4S GitHub team for GSoC participants. Accepting this invite will grant you access to internal resources and coordination tools.👉 https://github.com/orgs/llm4s/teams/gsoc/members
• 📌 Private GSoC Project Tracking Board: Once you're part of the team, you will have access to our private GSoC tracking board. This board helps you track tasks, timelines, and project deliverables throughout the GSoC period. 👉 https://github.com/orgs/llm4s/projects/3

• Contributor: Elvan Konukseven | GSoC Final Report URL
• LinkedIn: https://www.linkedin.com/in/elvan-konukseven/ | Email: [email protected] | Discord: elvan_31441
• Mentors: Kannupriya Kalra (Email: [email protected]), Rory Graves (Email: [email protected])
• Announcement: Official Acceptance Post | Volunteering at Scala Center 1, 2, 3 | Python Vs Scala
• Contributor Blogs: 📌 elvankonukseven.com/blog
• Work log: 📌 GitHub Project Board

• Contributor: Gopi Trinadh Maddikunta | GSoC Final Report URL
• LinkedIn: https://www.linkedin.com/in/gopitrinadhmaddikunta/ | Email: [email protected] | Discord: g3nadh_58439
• Mentors: Kannupriya Kalra (Email: [email protected]), Rory Graves (Email: [email protected]), Dmitry Mamonov (Email: [email protected])
• Announcement: Official Acceptance Post | Midterm evaluation post | Lightning talk post| GSoC Final Report post
• Contributor Blogs: 📌 Main Blog | 📌 Scala at Light Speed – Part 1 | 📌 Scala at Light Speed – Part 2
• Work log: 📌 Work Log → GitHub Project

• Contributor: Anshuman Awasthi | GSoC Final Report URL
• LinkedIn: https://www.linkedin.com/in/let-me-try-to-fork-your-responsibilities/ | Email: [email protected] | Discord: anshuman23026
• Mentors: Kannupriya Kalra (Email: [email protected]), Rory Graves (Email: [email protected])
• Announcement: Official Acceptance Post | Midterm evaluation post | Rock the JVM post | Lightning talk post | GSoC Final Report post
• Contributor Blogs: 📌 Anshuman's GSoC Journey
• Work Log: 📌 GitHub Project Board

• Contributor: Shubham Vishwakarma | GSoC Final Report URL
• LinkedIn: https://www.linkedin.com/in/shubham-vish/ | Email: [email protected] | Discord: oxygen4076
• Mentors: Kannupriya Kalra (Email: [email protected]), Rory Graves (Email: [email protected]), Dmitry Mamonov (Email: [email protected])
• Announcement: Official Acceptance Post | Midterm evaluation post | Midway journey post | Lightning talk post | Rock the JVM post
• Contributor Blogs: 📌 Cracking the Code: My GSoC 2025 Story
• Work log: 📌 GitHub Project Board

Feel free to reach out to the contributors or mentors listed for any guidance or questions related to GSoC 2026.

Contributors selected across the globe for GSoC 2025 program.

We’ve got exciting news to share - Scalac, one of the leading Scala development companies, has officially partnered with LLM4S for a dedicated AI-focused blog series!

This collaboration was initiated after our talk at Functional World 2025, and it’s now evolving into a full-fledged multi-part series and an upcoming eBook hosted on Scalac’s platform. The series will combine practical Scala code, GenAI architecture, and reflections from the LLM4S team - making it accessible for Scala developers everywhere who want to build with LLMs.

📝 The first post is already drafted and under review by the Scalac editorial team. We’re working together to ensure this content is both technically insightful and visually engaging.

🎉 Thanks to Matylda Kamińska, Rafał Kruczek, and the Scalac marketing team for this opportunity and collaboration!

Stay tuned - the series will be published soon on scalac.io/blog, and we’ll link it here as it goes live.

LLM4S blogs powered by Scalac.

Technical deep-dives, production stories, and insights from LLM4S contributors. These articles chronicle real-world implementations, architectural decisions, and lessons learned from building type-safe LLM infrastructure in Scala.

💡 You can contribute writing blogs Share your LLM4S experience, architectural insights, or production lessons. Reach out to maintainers on Discord or create a PR updating this table.

Our Google Summer of Code (GSoC) 2025 contributors have actively documented their journeys, sharing insights and implementation deep-dives from their projects. These blog posts offer valuable perspectives on how LLM4S is evolving from a contributor-first lens.

💡 These blogs reflect first-hand experience in building real-world AI tools using Scala, and are great resources for future contributors and researchers alike.

• 🌐 Main Blog
• 📝 Articles:
  • The Application
  • First Task
  • Final GSoC Report URL

• 🌐 Main Blog
• 📝 Articles:
  • Spark of Curiosity
  • The Hunt Begins
  • Enter Scala Center
  • Understanding the Mission
  • Locking the Vision
  • The Proposal Sprint)
  • The Acceptance Moment
  • Stepping In
  • Fiel for the Mission
  • Scala at Light Speed – Part 1
  • Scala at Light Speed – Part 2
  • From Documents to Embeddings
  • Universal Extraction + Embedding Client = One step closer to RAG
  • Midterm Milestone- Modular RAG in Motion
  • GSoC Final Report URL

• 🌐 Main Blog : Anshuman's GSoC Journey
• 📝 Articles:
  • My Journey to Google Summer of Code 2025
  • Community Bonding Experience at GSoC 2025
  • Milestone 1 : Successfully Added Image Generation Capabilities into the LLM4S Library
  • GSoC Final Report URL

• 🌐 Main Blog : Shubham's GSoC Journey
• 📝 Articles:
  • Cracking the Code: My GSoC 2025 Story
  • My Scala Sprint: JVM to Poland Insights
  • GSoC Final Report URL

Want to connect with maintainers? The LLM4S project is maintained by:

• Rory Graves - https://www.linkedin.com/in/roryjgraves/ | Email: [email protected] | Discord: rorybot1
• Kannupriya Kalra - https://www.linkedin.com/in/kannupriyakalra/ | Email: [email protected] | Discord: kannupriyakalra_46520

This project is licensed under the MIT License - see the LICENSE file for details.