My Agentic Starter Kit: Tools for Hitting the Ground Running

Hey everyone, Riley Fox here, back at agntkit.net!

Today, I want to talk about something that’s been on my mind a lot lately, especially as I’ve been diving deeper into personal automation and agentic workflows: the idea of a “starter kit.” But not just any starter kit – I’m talking about the kind of carefully curated, battle-tested collection of tools, scripts, and configurations that you can hand to someone (or yourself, six months from now) and say, “Here. This is how you hit the ground running.”

We’ve all been there, right? Staring at a blank slate, whether it’s a new project, a fresh OS install, or even just trying to get a handle on a new domain like, say, advanced web scraping or local LLM orchestration. The sheer volume of choices can be paralyzing. Do I use Python or Node.js for this? Which library is the current darling? What’s the best way to manage dependencies? And don’t even get me started on environment variables.

For a long time, my approach was what I’d call “organic growth.” I’d add tools as I needed them, create scripts ad-hoc, and generally let my system evolve like a digital jungle. It worked, mostly. But then I’d inevitably hit a wall. A new laptop meant painstakingly recreating my setup. A shared project meant endless Slack messages explaining dependencies. And trying to onboard a new collaborator? Forget about it. It was like giving them a map of a city I’d built myself, without any street names.

That’s why I’ve become obsessed with the concept of the “Agentic Starter Kit.”

The Agentic Starter Kit: More Than Just a List

What exactly do I mean by an “Agentic Starter Kit?” It’s not just a list of my favorite apps or a simple `requirements.txt` file. It’s a cohesive, opinionated collection designed to accelerate specific types of agentic work. Think of it as a pre-configured workspace, ready to tackle common challenges in automation, data gathering, or task execution with minimal fuss. It’s about reducing cognitive load and maximizing throughput from day one.

My current focus for this kind of kit is around local LLM experimentation and automation. The tooling in this space moves at warp speed. What was cutting-edge last month might be old news today. So, an effective starter kit here isn’t just about picking the “best” tools; it’s about picking robust, well-supported tools that integrate nicely and offer a clear path forward, even as the ecosystem shifts.

Why Even Bother Building One?

• Speed of Onboarding: For new team members, or even just future you, a starter kit cuts down setup time from days to minutes.
• Consistency: Everyone’s working with the same versions, the same configurations. Fewer “it works on my machine” moments.
• Best Practices Encapsulated: You bake in your preferred folder structures, security settings, and coding standards right from the start.
• Reduced Decision Fatigue: When you’re trying to get a new project off the ground, having a pre-vetted set of tools saves you from endless research loops.
• Experimentation Ground: It provides a stable base from which to try new things without fear of breaking your core setup.

I recently had a moment of clarity on this. I was trying to spin up a new local LLM agent to monitor specific RSS feeds and summarize new entries, then push them to a private Discord channel. I’d done similar things before, but each time I found myself re-installing a bunch of stuff, hunting down old scripts, and trying to remember which `ollama` model I preferred for summarization. It was a mess. That’s when I decided to formalize my “LLM Automation Starter Kit.”

My Current LLM Automation Starter Kit (2026-05-18 Edition)

Here’s a peek into what’s currently in my personal starter kit for local LLM automation, along with some reasoning and examples.

1. Environment Management: Conda (or Mamba)

I know, I know. Python virtual environments are a religious topic. I’ve used `venv`, `pipenv`, and `poetry`. For me, especially when dealing with the often-complex dependencies of ML libraries (CUDA, PyTorch, etc.), `conda` (or its faster cousin, `mamba`) has been a lifesaver. It handles non-Python dependencies and makes creating reproducible environments much simpler.

Why: It just works for complex setups. I can create an environment specifically for LLM tasks without polluting my base Python install or wrestling with system-level library conflicts.

Example Snippet (environment.yml):

name: llm_agent_kit
channels:
 - defaults
 - conda-forge
dependencies:
 - python=3.10
 - pip
 - numpy
 - pandas
 - requests
 - beautifulsoup4
 - lxml
 - rich
 - langchain
 - pydantic
 - openai # For potential OpenAI API integration, though we focus local
 - chromadb # For local vector store
 - python-dotenv
 - pip:
 - ollama==0.1.30 # Pinning a specific version I know works well
 - litellm==1.36.0
 - unstructured==0.12.6
 - instructor==0.5.2

This `environment.yml` becomes the blueprint. Anyone can `conda env create -f environment.yml` and instantly have my baseline setup.

2. Local LLM Runtime: Ollama

For running models locally, `Ollama` is currently my go-to. It’s incredibly easy to install, supports a wide range of models, and provides a simple API that works wonderfully with libraries like `LiteLLM` and `LangChain`.

Why: Simplicity, broad model support, and a stable API. It abstracts away a lot of the CUDA/GPU setup headaches that used to plague local LLM experimentation.

Example Usage (after ollama run llama2):

import ollama

def summarize_text_ollama(text: str, model: str = "llama2"):
 prompt = f"Summarize the following text concisely:\n\n{text}"
 response = ollama.chat(
 model=model,
 messages=[{'role': 'user', 'content': prompt}]
 )
 return response['message']['content']

# Example
article_text = "The quick brown fox jumps over the lazy dog. This is a classic sentence used for testing typefaces and other text-related applications. It contains all letters of the alphabet."
summary = summarize_text_ollama(article_text)
print(f"Summary: {summary}")

3. LLM Orchestration & Tooling: LiteLLM & LangChain

I often get asked if I use `LangChain` or `LiteLLM`. My answer? Both, depending on the need. `LiteLLM` is fantastic for a unified API across different LLM providers (local or remote) and for robust error handling/retries. `LangChain` provides higher-level abstractions for agents, chains, and complex RAG workflows.

Why: `LiteLLM` handles the low-level communication reliably. `LangChain` gives me the building blocks for creating sophisticated agents without reinventing the wheel every time.

Example Snippet (combining LiteLLM with a LangChain tool):

Let’s say we want an agent that can search the web. We can define a tool and integrate it.

from langchain.agents import AgentExecutor, create_react_agent
from langchain_core.prompts import PromptTemplate
from langchain_core.tools import tool
from litellm import completion

# Basic web search tool (replace with a real search API for production)
@tool
def web_search(query: str) -> str:
 """Searches the web for the given query and returns a snippet of information."""
 # In a real kit, this would integrate with a SerpAPI, Google Custom Search, etc.
 # For demonstration, a placeholder:
 if "latest AI news" in query.lower():
 return "AI is rapidly advancing, with new models and applications emerging daily. Focus areas include multimodal AI, smaller efficient models, and enhanced agentic capabilities."
 return f"Simulated search result for '{query}': Information about {query} found."

# LiteLLM integration for a local Ollama model
# Set environment variable: os.environ["OLLAMA_API_BASE"] = "http://localhost:11434"
# os.environ["LLM_MODEL"] = "ollama/llama2" # Or whatever model you pull via ollama

def call_ollama_with_litellm(messages):
 response = completion(model="ollama/llama2", messages=messages)
 return response.choices[0].message.content

# LangChain agent setup
tools = [web_search]
prompt = PromptTemplate.from_template("""
You are a helpful AI assistant. You have access to the following tools:
{tools}

Use the following format:

Question: the input question you must answer
Thought: you should always think about what to do
Action: the action to take, should be one of [{tool_names}]
Action Input: the input to the action
Observation: the result of the action
... (this Thought/Action/Action Input/Observation can repeat N times)
Thought: I now know the final answer
Final Answer: the final answer to the original input question

Begin!

Question: {input}
Thought:{agent_scratchpad}
""")

agent = create_react_agent(call_ollama_with_litellm, tools, prompt) # Pass LiteLLM function directly
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# Run the agent
print(agent_executor.invoke({"input": "What's the latest in AI news and what is Python?"}))

This shows how `LiteLLM` can be slotted in as the LLM provider for `LangChain`, giving you flexibility while keeping your core agent logic clean.

4. Data Handling & Scraping: Requests, BeautifulSoup, Unstructured

Agents often need to interact with the real world, which means fetching and parsing data. `requests` is the standard for HTTP. `BeautifulSoup` and `lxml` are excellent for parsing HTML. For more complex document types (PDFs, Word docs, etc.), `unstructured` is a fantastic addition that simplifies text extraction.

Why: These are the foundational tools for getting data into your agent’s context. `Unstructured` specifically saves a ton of time on pre-processing various file types for RAG.

Example Snippet (basic data fetch and parse):

import requests
from bs4 import BeautifulSoup

def fetch_and_parse_title(url: str) -> str:
 try:
 response = requests.get(url, timeout=10)
 response.raise_for_status() # Raise an exception for HTTP errors
 soup = BeautifulSoup(response.text, 'lxml')
 title = soup.find('title')
 return title.text if title else "No title found"
 except requests.exceptions.RequestException as e:
 return f"Error fetching URL: {e}"

# Example
url_to_scrape = "https://agntkit.net"
page_title = fetch_and_parse_title(url_to_scrape)
print(f"Title of {url_to_scrape}: {page_title}")

5. Structuring Output: Pydantic & Instructor

One of the biggest headaches with LLMs can be getting them to output structured data reliably. `Pydantic` models are perfect for defining the schema you expect. `Instructor` is a brilliant library that wraps your LLM calls to force output into `Pydantic` models, even with local models.

Why: This is crucial for building reliable agents. If your agent is supposed to extract names and addresses, you don’t want it returning a free-form paragraph. `Pydantic` + `Instructor` ensures consistency.

Example Snippet:

from pydantic import BaseModel, Field
import instructor
from litellm import completion

# Patch LiteLLM with instructor for structured output
client = instructor.patch(completion)

class MeetingSummary(BaseModel):
 """Summarizes a meeting transcript, extracting key details."""
 meeting_title: str = Field(description="Concise title of the meeting.")
 attendees: list[str] = Field(description="List of all attendees.")
 key_decisions: list[str] = Field(description="Important decisions made.")
 action_items: list[str] = Field(description="Tasks assigned with owner if possible.")
 sentiment: str = Field(description="Overall sentiment of the meeting (positive, neutral, negative).")

meeting_transcript = """
Attendees: Alice, Bob, Charlie, David
Meeting started at 10:00 AM.
Alice: We need to finalize the Q3 budget. Bob, can you get the numbers by end of day?
Bob: Yes, I'll send them over.
Charlie: The marketing campaign launch is on track. David, remember to send out the press release drafts.
David: Will do.
Alice: Great. Decision: Q3 budget to be finalized by Friday. Action: Bob to send numbers. Action: David to send press release drafts.
Meeting adjourned at 10:30 AM.
"""

summary_object: MeetingSummary = client.chat.completions.create(
 model="ollama/llama2", # Ensure llama2 is pulled via ollama
 response_model=MeetingSummary,
 messages=[
 {"role": "user", "content": f"Summarize this meeting transcript:\n\n{meeting_transcript}"},
 ]
)

print(summary_object.model_dump_json(indent=2))

This is incredibly powerful. You define what you want, and `Instructor` nudges the LLM to give it to you in that exact format.

Actionable Takeaways for Building Your Own Starter Kit

So, how do you go about building your own Agentic Starter Kit? Here are my thoughts:

1. Identify Your Core Problem Domain: Don’t try to build a kit for “everything.” Focus on a specific area where you repeatedly find yourself setting things up from scratch (e.g., web scraping, LLM agents, data analysis, cloud deployments).
2. Start Small, Iterate Often: Begin with 2-3 essential tools. As you encounter recurring setup tasks or dependencies, add them to your kit. My LLM kit didn’t start with all those libraries; it grew organically as I built more complex agents.
3. Document Everything: This is crucial. Even if it’s just for yourself. How do you install it? What are the common gotchas? What environment variables are needed? A `README.md` is your best friend.
4. Prioritize Reproducibility: Use environment managers (Conda, Docker) and pin your dependencies (e.g., `ollama==0.1.30`). Future you (and your teammates) will thank you.
5. Include Example Usage: A kit isn’t just about the tools; it’s about showing how to use them. Simple scripts or Jupyter notebooks that demonstrate common workflows are incredibly valuable.
6. Keep it Opinionated (Within Reason): Don’t try to support every possible permutation. Make choices based on what works best for *you* and *your team*. You can always swap out components later if needs change.
7. Automate Setup: If possible, create a `setup.sh` or `Makefile` that automates the environment creation and dependency installation. The less manual intervention, the better.

Building an Agentic Starter Kit isn’t a one-time thing. It’s an ongoing process of refinement and adaptation. As the tools evolve, so too will your kit. But the upfront investment in creating this structured foundation will pay dividends in speed, consistency, and reduced frustration. It’s about building a launchpad for your agentic endeavors, not just a pile of spare parts.

What’s in your essential starter kit? I’d love to hear about it in the comments below!

🕒 Published: May 18, 2026