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* [email protected]
https://github.com/Shevilll
--
You received this message because you are subscribed to the Google Groups
"sympy" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
To view this discussion visit
https://groups.google.com/d/msgid/sympy/6466a8e5-5b94-4e75-a1c1-7874254653c3n%40googlegroups.com.
