GSoC 2025 - SymPy LLM Tool Agent Project | Project Proposal

[AhmadFaraz]

Greetings, SymPy Developers,

I hope this email finds you well. My name is Ahmad Faraz, and I’m a Computer Science and Engineering student at Amity University Jharkhand, India, with a strong interest in symbolic computation and AI. I’m reaching out regarding the "Official LLM Tool Agent for SymPy" project listed in the SymPy GSoC 2025 ideas. I’m excited about the potential to bridge SymPy’s powerful symbolic capabilities with Large Language Models, and I’d love to contribute to this under your mentorship.

I’ve drafted an initial proposal outlining my approach to this project, which I’ve attached for your review. It includes my plan to create a structured SymPy interface for LLMs, integrate with frameworks like LangChain, and support multi-step mathematical workflows (e.g., minimization, differential equations). I’d greatly appreciate your feedback on this proposal or any guidance on refining it to align with SymPy’s goals for GSoC 2025.

A bit about me: I have experience in Python programming, working with SymPy for symbolic math, and experimenting with LLM frameworks like LangChain. A 2nd year student, with a CGPA of 9.73. I've interest in mathematics and computer science. I've developed many small to medium sized projects using python and other languages. I’m eager to dive deeper into SymPy’s codebase and LLM tool-calling mechanisms, and I believe this project is a perfect fit for my skills and interests.

Abstract

This project aims to develop an official LLM Tool Agent for SymPy, enabling Large Language Models (LLMs) to interact with SymPy’s symbolic computation library through a structured, framework-agnostic interface. The agent will allow LLMs to interpret natural language math problems, map them to SymPy function calls, and execute multi-step workflows (e.g., finding function minima, solving differential equations). By creating a machine-readable SymPy interface, integrating with frameworks like LangChain, and providing testing/debugging tools, this project will enhance SymPy’s accessibility to AI-driven applications.

Project Goals

1. SymPy Interface for LLMs: Create a JSON-based schema of SymPy’s public functions/classes (e.g., diff, solve, integrate) with descriptions, parameters, and examples.
2. Tool Agent Implementation: Build a Python-based agent to parse LLM-generated plans and execute SymPy calls, supporting multi-step operations.
3. Framework Integration: Develop templates for at least one LLM framework (e.g., LangChain) with plans to extend to others (e.g., LlamaIndex, Haystack).
4. Testing and Metrics: Implement a test suite to evaluate correctness and performance, reporting statistical metrics (e.g., accuracy, latency).
5. Debugging Interface: Design a basic CLI or web-based tool to trace LLM plans and SymPy outputs for debugging.

Proposed Timeline

(For a 175-hour project; expandable to 350 hours with additional features)

• Weeks 1-2 (20 hours): Research SymPy codebase, extract function metadata, design JSON schema.
• Weeks 3-5 (50 hours): Build core agent logic for single-step and multi-step SymPy calls.
• Weeks 6-8 (50 hours): Integrate with LangChain, test with example problems (e.g., minimization, differential equations).
• Weeks 9-10 (35 hours): Develop test suite, calculate metrics, refine based on results.
• Weeks 11-12 (20 hours): Create debugging interface, document code, prepare deliverables.
• (Optional 350-hour Extensions): Add multi-framework support (50 hours), enhance testing (50 hours), build a web UI (50 hours).

Deliverables

• A machine-readable SymPy interface (JSON/YAML).
• A functional LLM Tool Agent in Python.
• LangChain integration with example workflows.
• Test suite with metrics report.
• Debugging tool and documentation.

Example Workflow

For "Find the minimum of x^2 + y^2 subject to x + y = 1":

1. LLM generates a plan: define symbols, set up function/constraint, compute derivatives, solve system.
2. Agent executes:

• x, y = symbols('x y')
• f = x**2 + y**2
• constraint = Eq(x + y, 1)
• dx, dy = diff(f, x), diff(f, y)
• sol = solve([dx, dy, constraint], (x, y))

        3. Output: Solution (x=0.5, y=0.5) with trace logged for debugging.

Background and Skills

• Proficient in Python and familiar with SymPy for symbolic math.
• Experience with "LLM frameworks like LangChain" or "tool-calling APIs".
• Comfortable with "self-hosting LLMs" or "writing test suites".
• Eager to learn SymPy internals and contribute to open-source.

Why This Project?

I’m passionate about symbolic computation and AI, and this project combines both in a way that can significantly enhance SymPy’s utility. I see it as a chance to grow my skills in LLM integration while contributing a valuable tool to the SymPy community.

Questions for Mentors

• Are there preferred LLM frameworks or SymPy modules to prioritize?
• Should I focus on specific multi-step problem types initially?
• Any existing SymPy tools I should build upon?

Could we possibly schedule a time to discuss this further, or would you prefer I refine my proposal based on initial feedback via email?

Thank you for your time and consideration! I look forward to hearing from you. Regards, Ahmad Faraz ahmadfa...@gmail.com https://github.com/Shevilll