Skip to content

Building Intelligent Software Agents with LLMs and Knowledge Graphs - Course Description

Course Description

This 12-week course introduces students to the design, development, and deployment of intelligent software agents powered by Large Language Models (LLMs) and knowledge representation systems. Students will learn to build autonomous computational entities that perform tasks with independence while effectively representing user goals and domain knowledge.

Through hands-on projects and practical exercises, students will explore the spectrum of agent capabilities—from simple rule-based systems to sophisticated code-generating agents that can write and execute Python. The course emphasizes both theoretical foundations and practical implementation, with special focus on the emerging SmolAgents framework, local LLM deployment with Ollama, and effective knowledge representation techniques.

Learning Objectives

By the end of this course, students will be able to:

  • Implement various levels of LLM agent control (from basic decision-making to code generation)
  • Deploy and run local LLMs using Ollama and similar frameworks
  • Design effective tool catalogs with well-documented functions for agent use
  • Create agents that combine public knowledge (from LLMs) with private knowledge sources
  • Implement the ReAct framework to interleave reasoning and action in agent systems
  • Develop autonomous agents that can understand, generate, and execute Python code
  • Evaluate agent performance through structured peer review processes

Prerequisites

  • Intermediate Python programming skills
  • Basic understanding of data types and structures
  • Familiarity with GitHub or similar version control systems (helpful but not required)
  • Experience with IDEs such as Visual Studio (helpful but not required)
  • Basic understanding of command-line interfaces (helpful but not required)

Course Structure

Weeks 1-2: Foundations of Agent Systems

  • Introduction to software agents and agency levels
  • Knowledge representation fundamentals
  • Tools, tool calling, and tool catalogs
  • Setting up local development environments with Ollama

Weeks 3-4: LLM Integration and Local Deployment

  • Working with DeepSeek R1 and other lightweight LLMs
  • Prompt engineering for agent development
  • Building basic tool-calling agents
  • GPU optimization for local deployment

Weeks 5-6: Agent Frameworks

  • Introduction to SmolAgents library
  • Comparative analysis of agent frameworks (LangChain, PydanticAI)
  • The ReAct framework implementation
  • Creating custom tools with proper documentation

Weeks 7-8: Advanced Agent Capabilities

  • Code Agents: direct code generation and execution
  • Combining public and private knowledge sources
  • Building multi-agent systems
  • Error handling and safety considerations

Weeks 9-12: Capstone Project

  • Team formation and project planning
  • Milestone reviews and peer feedback sessions
  • Project implementation and iteration
  • Final presentations and demonstrations

Assessment Methods

  • Hands-on programming assignments (30%)
  • Midterm project: Basic agent implementation (15%)
  • Peer review participation and quality (20%)
  • Capstone project development and presentation (35%)

Required Tools

  • GitHub account (required)
  • Python 3.8+ with relevant libraries
  • GPU-compatible system for local LLM deployment (recommended)
  • Development environment (VS Code or similar IDE recommended)

Special Course Features

  • Weekly agent showcase sessions where students demonstrate their latest implementations
  • Industry guest lectures from professionals working with agent technologies
  • Collaborative problem-solving sessions using the intelligent textbook approach
  • Optional advanced tracks for students interested in specialized applications (educational agents, coding assistants, etc.)

Note to Prospective Students

This course operates at the intersection of artificial intelligence, software engineering, and knowledge representation. While we provide substantial guidance, students should be prepared for a highly experimental learning environment, as agent technologies are rapidly evolving. Creative problem-solving and adaptation to emerging frameworks will be essential for success in this course.

Questions

Do I have to have a computer with a GPU?

No, but it is strongly recommended.

What is a good enough local GPU?

The ideal system is one that has a minimum of 12GB of RAM such as a NVIDIA GTX series of Consumer/Gaming GPUs. Here are some examples:

  • GeForce RTX 4090 (24 GB)
  • GeForce RTX 4080 (16 GB)
  • GeForce RTX 3090 Ti (24 GB)
  • GeForce RTX 3090 (24 GB)
  • GeForce RTX 3080 Ti (12 GB)
  • GeForce RTX 3080 (12 GB version)

These systems all can generate over 50 tokens per second when running Ollama and the DeepSeek-R1 LLM. Using a local LLM means you don't need to pay high fees to cloud LLM service providers.

Note that the four year old GeForce RTX 3080 sells for approximately \(350-\)550 on marketplaces like eBay and Craigslist. You can often ask your friends of they have an old GPU that they are no longer using.