How to use SiliconFlow for data science

Last month, I was staring down a massive dataset of customer churn logs—thousands of rows of messy, unstructured text feedback alongside structured usage metrics. I needed to categorize the text, extract common complaints, and correlate them with churn rates. Doing this manually would have taken days. I had been experimenting with local LLMs for data analysis, but my GPU was choking on the larger models required for this kind of reasoning. That is when I decided to give SiliconFlow a spin.

SiliconFlow is an AI cloud platform that gives you API access to a massive library of open-source and commercial models—ranging from heavy hitters like DeepSeek-V4 and Qwen to specialized vision-language models—without making you manage the GPU infrastructure. After using it for a few weeks, here is my hands-on guide on how to actually use SiliconFlow for data science workflows.

Step 1: Getting Set Up (And Avoiding Early Mistakes)

First things first, head to the SiliconFlow website and create an account. You can log in via SMS, email, or OAuth through GitHub and Google.

Once you are in, you need to generate an API Key. Navigate to the API Keys section in your dashboard and click "Create API Key." Copy it immediately and store it safely—this is your golden ticket.

My first mistake: I immediately jumped into writing a Python script without checking the model catalog. SiliconFlow has dozens of models, and they all have different context windows, pricing, and capabilities. I initially tried to use a smaller, faster model for my churn analysis, but it kept hallucinating categories. When I went to the Models page in the dashboard, I realized I needed a model with stronger reasoning capabilities for complex data extraction. Do yourself a favor and browse the model list first to find the right tool for the job.

Step 2: The OpenAI Compatibility Trick

One of the best things about SiliconFlow is that it supports the OpenAI Python library interface. If you already have data science scripts written for OpenAI, migrating them is almost trivial.

Install the OpenAI Python library (make sure you are on Python 3.7.1 or higher):

pip install --upgrade openai

To test the connection, I wrote a quick script to categorize a sample of my customer feedback:

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_SILICONFLOW_API_KEY",
    base_url="https://api.siliconflow.com/v1"
)

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V4-Flash", # Using the Flash model for speed/cost
    messages=[
        {"role": "system", "content": "You are a data analyst. Categorize the following customer feedback into one of: Pricing, UI/UX, Performance, Support."},
        {"role": "user", "content": "The app takes 10 seconds to load the dashboard and sometimes crashes when I export CSV files."}
    ],
    temperature=0.1
)

print(response.choices[0].message.content)

The result came back instantly: Performance. The DeepSeek-V4-Flash model is incredibly cheap (fractions of a cent per token) and blazing fast, making it perfect for bulk data classification tasks. I proceeded to run 5,000 rows of feedback through this exact endpoint, and it handled the workload flawlessly.

Step 3: Analyzing Charts and Visual Data with Vision Models

Text data is one thing, but data scientists often need to extract insights from visual assets—charts, plots, or scanned documents. This is where I was genuinely surprised by SiliconFlow's multimodal offerings.

I had a batch of auto-generated matplotlib scatter plots from a previous experiment, and I wanted to see if an LLM could identify outliers just by "looking" at the images. I used the Qwen2.5-VL-72B-Instruct model, which is a vision-language model available on the platform.

import base64
from openai import OpenAI

client = OpenAI(
    api_key="YOUR_SILICONFLOW_API_KEY",
    base_url="https://api.siliconflow.com/v1"
)

# Function to encode local images
def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode('utf-8')

base64_image = encode_image("scatter_plot_outliers.png")

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-VL-72B-Instruct",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Analyze this scatter plot. Are there any obvious outliers? Describe them based on the axis values."},
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/png;base64,{base64_image}"}
                }
            ]
        }
    ]
)

print(response.choices[0].message.content)

To my surprise, Qwen2.5-VL not only identified the outliers but accurately estimated their approximate X and Y coordinates based on the visual grid. If you are building pipelines that need to ingest visual data—like scanned invoices, PDF reports, or auto-generated dashboards—this is a game-changer.

Step 4: Building a Full Data Agent with DB-GPT

While writing Python scripts for specific tasks is great, sometimes you want an interactive agent that can query your database, run RAG (Retrieval-Augmented Generation), and generate reports autonomously. For this, I integrated SiliconFlow with DB-GPT, an open-source framework for building data applications.

Setting this up was a bit more involved, but worth it. First, clone the DB-GPT repo and set up the environment:

git clone https://github.com/eosphoros-ai/DB-GPT.git
cd DB-GPT

# DB-GPT requires Python >= 3.10
conda create -n dbgpt_env python=3.10
conda activate dbgpt_env

# Install dependencies for proxy model support
pip install -e ".[proxy]"

Next, copy the environment template and configure it to use SiliconFlow as the backend brain:

cp .env.template .env

Open the .env file and add your SiliconFlow credentials. This is where you tell DB-GPT to route all LLM and embedding requests through SiliconFlow:

# Use the proxy model from SiliconFlow
LLM_MODEL=siliconflow_proxyllm

# Specify the model name to use
SILICONFLOW_MODEL_VERSION=Qwen/Qwen2.5-Coder-32B-Instruct
SILICONFLOW_API_BASE=https://api.siliconflow.com/v1

# Enter your API Key
SILICONFLOW_API_KEY={your-siliconflow-api-key}

# Configure the Embedding model from SiliconFlow
EMBEDDING_MODEL=proxy_http_openapi
PROXY_HTTP_OPENAPI_PROXY_SERVER_URL=https://api.siliconflow.com/v1/embeddings
PROXY_HTTP_OPENAPI_PROXY_API_KEY={your-siliconflow-api-key}

# Specify the Embedding model name
PROXY_HTTP_OPENAPI_PROXY_MODEL=BAAI/bge-large-en-v1.5

Once configured, fire up DB-GPT. You now have a local data agent powered by SiliconFlow's cloud infrastructure. I connected it to my PostgreSQL database, and I was able to ask questions in plain English like, "What were the top 5 reasons for churn last quarter based on the feedback table?" DB-GPT generated the SQL, executed it, and summarized the results using the Qwen model I had specified.

Practical Tips and Honest Limitations

After spending a few weeks running data science workflows through SiliconFlow, here are my takeaways:

Tips:

Use the right model for the right task. Don't use a massive 1049K context window model for simple text classification. Use DeepSeek-V4-Flash for bulk labeling and save the heavy models (like DeepSeek-V4-Pro or LongCat-2.0) for complex reasoning or large-context document summarization.
Leverage structured outputs. SiliconFlow supports structured output generation. If you are building a news database or extracting entities from reports, force the API to return JSON. It saves you from writing brittle regex parsers.
Test in the Playground first. Before writing a single line of code, use the SiliconFlow Experience Center (playground). You can tweak parameters and test prompts on the sidebar to ensure you get the desired output before you start spending API credits at scale.

Limitations:

Not all models support OpenAI parameters equally. While the platform claims support for "most parameters related to OpenAI," I ran into issues using some advanced features like logprobs or specific function-calling schemas with certain open-source models. Always check the model details page for compatibility.
Latency spikes on popular models. When a new model drops (like LongCat-2.0), everyone rushes to try it. During peak hours, I noticed slower inference times on the most popular models. If you are running time-sensitive production workloads, consider using slightly older or less hyped models for consistency.
DB-GPT setup is fragile. The DB-GPT integration is powerful, but the open-source project updates frequently. I had dependency conflicts on my first attempt. Make sure you strictly follow the Python 3.10 requirement and use a fresh virtual environment.

Overall, SiliconFlow has become my go-to for data science tasks that require heavy LLM lifting without the hassle of managing my own GPU cluster. The OpenAI-compatible API makes it drop-in ready for existing scripts, and the variety of models means I can fine-tune my approach based on exactly what my data demands.