PHPackages                             manik/neuro - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [API Development](/categories/api)
4. /
5. manik/neuro

ActiveLibrary[API Development](/categories/api)

manik/neuro
===========

A unified AI interface for Laravel — LLMs, embeddings, vector databases, RAG pipelines, agents, and more.

v1.1.0(1mo ago)981MITPHPPHP ^8.3

Since Jun 2Pushed 1mo agoCompare

[ Source](https://github.com/dev-manik-mia/neuro)[ Packagist](https://packagist.org/packages/manik/neuro)[ RSS](/packages/manik-neuro/feed)WikiDiscussions main Synced 1w ago

READMEChangelog (2)Dependencies (4)Versions (5)Used By (0)

Neuro: Laravel AI Framework
===========================

[](#neuro-laravel-ai-framework)

A unified AI interface for Laravel — LLMs, embeddings, vector databases, RAG pipelines, agents, and more.

[![PHP](https://camo.githubusercontent.com/c8d8dad6beb757a2b8acba331d16140813699543b88a37af0a81f20bd35f61de/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f5048502d382e332532422d626c7565)](https://php.net)[![Laravel](https://camo.githubusercontent.com/1e9d92f3aff9271e2cafc753d2327ae7db0f1694ccc374b5e850349b994223d5/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4c61726176656c2d31312e7825323025374325323031322e7825323025374325323031332e782d726564)](https://laravel.com)[![Packagist](https://camo.githubusercontent.com/6b133f1e963adf65ec80ff7a09106c676e30ee71a2a78569402ea96caff56bca/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f7061636b61676973742d6d616e696b2f6e6575726f2d677265656e)](https://packagist.org/packages/manik/neuro)

---

- [Installation](#installation)
- [Configuration](#configuration)
- [Quick Start](#quick-start)
- [LLM Providers](#llm-providers)
- [Embedding Providers](#embedding-providers)
- [Vector Databases](#vector-databases)
- [RAG Pipeline](#rag-pipeline)
- [Agents & Tool Calling](#agents--tool-calling)
- [Memory](#memory)
- [Image Generation](#image-generation)
- [Speech Processing](#speech-processing)
- [Document Ingestion & Chunking](#document-ingestion--chunking)
- [Testing](#testing)
- [Events & Observability](#events--observability)
- [Architecture](#architecture)

---

Installation
------------

[](#installation)

```
composer require manik/neuro
```

Publish the configuration:

```
php artisan vendor:publish --tag=neuro-config
```

Run migrations (for persistent memory and document storage):

```
php artisan migrate
```

Configuration
-------------

[](#configuration)

Add the following to your `.env` file based on the providers you use:

### LLM Providers

[](#llm-providers)

```
# OpenAI
AI_DEFAULT_LLM=openai
OPENAI_API_KEY=sk-...
OPENAI_LLM_MODEL=gpt-4o

# Anthropic
ANTHROPIC_API_KEY=sk-ant-...
ANTHROPIC_LLM_MODEL=claude-3-5-sonnet-20241022

# Google Gemini
GEMINI_API_KEY=...
GEMINI_LLM_MODEL=gemini-2.0-flash

# Local Ollama
AI_DEFAULT_LLM=ollama
OLLAMA_BASE_URL=http://localhost:11434
OLLAMA_LLM_MODEL=llama3

# xAI Grok
XAI_API_KEY=...
XAI_LLM_MODEL=grok-2

# Mistral
MISTRAL_API_KEY=...
MISTRAL_LLM_MODEL=mistral-large-latest

# Cohere
COHERE_API_KEY=...
COHERE_LLM_MODEL=command-r-plus
```

### Embedding Providers

[](#embedding-providers)

```
# Default
AI_DEFAULT_EMBEDDING=openai
OPENAI_API_KEY=sk-...
OPENAI_EMBEDDING_MODEL=text-embedding-3-small

# Local Ollama (no API key needed)
AI_DEFAULT_EMBEDDING=ollama
OLLAMA_BASE_URL=http://localhost:11434
OLLAMA_EMBEDDING_MODEL=llama3

# Gemini
GEMINI_API_KEY=...
GEMINI_EMBEDDING_MODEL=text-embedding-004

# Mistral
MISTRAL_API_KEY=...
MISTRAL_EMBEDDING_MODEL=mistral-embed

# Cohere
COHERE_API_KEY=...
COHERE_EMBEDDING_MODEL=embed-english-v3.0
```

### Vector Databases

[](#vector-databases)

```
# Default
AI_DEFAULT_VECTOR=qdrant
QDRANT_HOST=http://localhost:6333

# Pinecone
AI_DEFAULT_VECTOR=pinecone
PINECONE_API_KEY=...
PINECONE_ENVIRONMENT=...
PINECONE_INDEX_HOST=https://...pinecone.io

# pgvector
AI_DEFAULT_VECTOR=pgvector
PGVECTOR_CONNECTION=pgsql
PGVECTOR_TABLE=vector_embeddings
PGVECTOR_DIMENSIONS=1536

# Weaviate
AI_DEFAULT_VECTOR=weaviate
WEAVIATE_HOST=http://localhost:8080

# Milvus (v2 API)
AI_DEFAULT_VECTOR=milvus
MILVUS_HOST=http://localhost:19530
MILVUS_TOKEN=your_token

# Chroma
AI_DEFAULT_VECTOR=chroma
CHROMA_HOST=http://localhost:8000

# Vector Collections (optional — overrides the default collection name per driver)
AI_DEFAULT_VECTOR_COLLECTION=default
QDRANT_COLLECTION=my_qdrant_collection
PINECONE_COLLECTION=my_pinecone_index
PGVECTOR_COLLECTION=my_pgvector_collection
WEAVIATE_COLLECTION=MyWeaviateClass
MILVUS_COLLECTION=my_milvus_collection
CHROMA_COLLECTION=my_chroma_collection
```

All vector database methods accept a collection name as the first argument. If omitted or `null`, the driver falls back to the per-driver `collection` config, then to `AI_DEFAULT_VECTOR_COLLECTION`, then to `'default'`:

```
use Neuro::vector()->driver()->defaultCollection(); // resolves the fallback chain
Neuro::vector()->upsert('my_collection', $records); // explicit name
Neuro::vector()->upsert(null, $records);            // uses config fallback
```

### Temperature & Generation Settings

[](#temperature--generation-settings)

Configure temperature, max tokens, and timeout per provider:

```
# OpenAI
OPENAI_TEMPERATURE=0.7
OPENAI_MAX_TOKENS=4096
OPENAI_TIMEOUT=60

# Anthropic
ANTHROPIC_TEMPERATURE=0.7
ANTHROPIC_MAX_TOKENS=4096

# Gemini
GEMINI_TEMPERATURE=0.7
GEMINI_MAX_TOKENS=4096

# Ollama
OLLAMA_TEMPERATURE=0.7
OLLAMA_MAX_TOKENS=4096
OLLAMA_TIMEOUT=120

# Grok (xAI)
XAI_TEMPERATURE=0.7

# Mistral
MISTRAL_TEMPERATURE=0.7

# Cohere
COHERE_TEMPERATURE=0.7
```

Override temperature at runtime:

```
$response = Neuro::chat()
    ->provider('openai')
    ->model('gpt-4o')
    ->message('Explain Laravel')
    ->options(['temperature' => 0.3])
    ->chat();
```

### System Instructions

[](#system-instructions)

Cross-driver support for system prompts. Pass a message with `role: 'system'`:

```
$response = Neuro::chat()
    ->message(['role' => 'system', 'content' => 'You are a helpful assistant.'])
    ->message('Explain Laravel')
    ->chat();
```

The driver automatically handles the provider-specific format:

DriverAPI FieldOpenAI`messages[].role = system` (native)AnthropicTop-level `system` fieldGemini`systemInstruction` fieldCohere`preamble` fieldOllama`messages[].role = system` (native)Grok`messages[].role = system` (native)Mistral`messages[].role = system` (native)### Embedding Dimensions

[](#embedding-dimensions)

Control embedding output dimensions to ensure compatibility with your vector database:

```
# OpenAI (default: 1536)
OPENAI_EMBEDDING_DIMENSIONS=768

# Gemini (default: 768 — use 768 to match Qdrant collections)
GEMINI_EMBEDDING_DIMENSIONS=768

# Ollama
OLLAMA_EMBEDDING_DIMENSIONS=4096

# Mistral
MISTRAL_EMBEDDING_DIMENSIONS=1024

# Cohere
COHERE_EMBEDDING_DIMENSIONS=1024
```

### RAG Configuration

[](#rag-configuration)

```
AI_RAG_CHUNK_STRATEGY=recursive
AI_RAG_CHUNK_SIZE=1000
AI_RAG_CHUNK_OVERLAP=200
AI_RAG_TOP_K=5
AI_RAG_MIN_SCORE=0.0
```

### Cache & Rate Limiting

[](#cache--rate-limiting)

```
AI_CACHE_ENABLED=false
AI_CACHE_STORE=redis
AI_CACHE_TTL=3600

AI_RATE_LIMIT_ENABLED=false
AI_RATE_LIMIT_MAX=60
AI_RATE_LIMIT_DECAY=60
```

Quick Start
-----------

[](#quick-start)

```
use Manik\Neuro\Facades\Neuro;
```

### Chat Completion

[](#chat-completion)

```
$response = Neuro::chat()
    ->provider('openai')
    ->model('gpt-4o')
    ->message('Explain Laravel to a beginner')
    ->chat();

// $response['content'] => string
// $response['role'] => 'assistant'
```

### Streaming Chat

[](#streaming-chat)

```
$stream = Neuro::chat()
    ->provider('openai')
    ->message('Write a poem about Laravel')
    ->stream();

foreach ($stream as $chunk) {
    echo $chunk['content'];
    ob_flush();
    flush();
}
```

### Embeddings

[](#embeddings)

```
$result = Neuro::chat()
    ->text('The text to embed')
    ->embed('openai');

// $result['embedding'] => array of floats
// $result['dimensions'] => int
```

Batch embed:

```
$results = Neuro::chat()
    ->embedBatch(['text one', 'text two', 'text three'], 'openai');
```

### Vector Search

[](#vector-search)

```
$results = Neuro::vector()
    ->driver('qdrant')
    ->search('my_collection', $vector, ['top_k' => 10]);
```

LLM Providers
-------------

[](#llm-providers-1)

Use the `Neuro::llm()` method to access the LLM manager directly:

```
$driver = Neuro::llm()->driver('openai');
$response = $driver->chat([['role' => 'user', 'content' => 'Hello!']]);
```

### Supported Providers

[](#supported-providers)

ProviderDriver KeyChatStreamToolsConfig KeyOpenAI`openai`✅✅✅`ai.llm.openai`Anthropic`anthropic`✅✅✅`ai.llm.anthropic`Google Gemini`gemini`✅✅❌`ai.llm.gemini`Ollama`ollama`✅✅✅`ai.llm.ollama`xAI Grok`grok`✅✅✅`ai.llm.grok`Mistral`mistral`✅✅✅`ai.llm.mistral`Cohere`cohere`✅✅✅`ai.llm.cohere`### Tool Calling

[](#tool-calling)

```
$response = Neuro::chat()
    ->provider('openai')
    ->model('gpt-4o')
    ->message('What is the weather in Paris?')
    ->tools([
        [
            'type' => 'function',
            'function' => [
                'name' => 'get_weather',
                'description' => 'Get the weather for a city',
                'parameters' => [
                    'type' => 'object',
                    'properties' => [
                        'city' => ['type' => 'string'],
                    ],
                ],
            ],
        ],
    ]);
```

### Custom Ollama Setup

[](#custom-ollama-setup)

Ollama runs locally with no API key required:

```
# Install Ollama
brew install ollama

# Pull a model
ollama pull llama3

# Run the server
ollama serve
```

```
AI_DEFAULT_LLM=ollama
OLLAMA_BASE_URL=http://localhost:11434
OLLAMA_LLM_MODEL=llama3
```

```
$response = Neuro::chat()
    ->provider('ollama')
    ->model('llama3')
    ->message('Hello, how are you?')
    ->chat();
```

Embedding Providers
-------------------

[](#embedding-providers-1)

ProviderDriver KeyDefault DimensionsConfig KeyOpenAI`openai`1536`ai.embedding.openai`Ollama`ollama`4096`ai.embedding.ollama`Gemini`gemini`768`ai.embedding.gemini`Mistral`mistral`1024`ai.embedding.mistral`Cohere`cohere`1024`ai.embedding.cohere`Override dimensions via `.env` to match your vector database:

```
OPENAI_EMBEDDING_DIMENSIONS=768
GEMINI_EMBEDDING_DIMENSIONS=768
```

```
$vector = Neuro::embedding()
    ->driver('openai')
    ->embed('Your text here');
```

Vector Databases
----------------

[](#vector-databases-1)

### Supported Databases

[](#supported-databases)

DatabaseDriver KeyCreateUpsertSearchDeleteFilterConfig KeyQdrant`qdrant`✅✅✅✅✅`ai.vector.qdrant`Pinecone`pinecone`❌✅✅✅✅`ai.vector.pinecone`pgvector`pgvector`✅✅✅✅✅`ai.vector.pgvector`Weaviate`weaviate`✅✅✅✅✅`ai.vector.weaviate`Milvus`milvus`✅✅✅✅✅`ai.vector.milvus`Chroma`chroma`✅✅✅✅✅`ai.vector.chroma`### Basic Usage

[](#basic-usage)

```
// Get a vector driver
$vector = Neuro::vector()->driver('qdrant');

// Create a collection
$vector->createCollection('knowledge', 1536);

// Upsert vectors
$vector->upsert('knowledge', [
    [
        'id' => '1',
        'vector' => [0.1, 0.2, ...],
        'payload' => ['text' => 'Some content', 'source' => 'docs'],
    ],
]);

// Search
$results = $vector->search('knowledge', [0.1, 0.2, ...], [
    'top_k' => 10,
    'filter' => ['source' => 'docs'],
]);

// Delete
$vector->delete('knowledge', '1');
```

### pgvector Setup

[](#pgvector-setup)

```
# Add pgvector extension to your PostgreSQL database
CREATE EXTENSION vector;

# Then use in your code
Neuro::vector()->driver('pgvector')
    ->createCollection('embeddings', 1536);

Neuro::vector()->driver('pgvector')
    ->upsert('embeddings', [
        [
            'id' => 'doc_1',
            'vector' => [0.1, 0.2, ...],
            'payload' => ['text' => 'Hello world'],
        ],
    ]);
```

### Qdrant Setup

[](#qdrant-setup)

```
# With Docker
docker run -p 6333:6333 qdrant/qdrant

# Then use in your code
Neuro::vector()->driver('qdrant')
    ->createCollection('documents', 1536);
```

RAG Pipeline
------------

[](#rag-pipeline)

The RAG (Retrieval Augmented Generation) pipeline retrieves relevant context from a vector store and uses it to answer questions.

### Basic RAG

[](#basic-rag)

```
$response = Neuro::rag()
    ->collection('knowledge_base')
    ->question('What is Laravel?')
    ->answer();

// $response['answer'] => string (the LLM's answer with context)
// $response['sources'] => array (the retrieved chunks)
// $response['tokens'] => array (token usage)
```

### Using the Pipeline Directly

[](#using-the-pipeline-directly)

```
$pipeline = Neuro::rag()->pipeline();

$response = $pipeline
    ->collection('knowledge_base')
    ->question('What is Laravel?')
    ->topK(10)
    ->minScore(0.5)
    ->answer();

// Just search without LLM
$results = $pipeline->search();
```

### The RAG Flow

[](#the-rag-flow)

```
User Question
    ↓
[1] Embed the question
    ↓
[2] Search vector database for similar content
    ↓
[3] Build context from retrieved chunks
    ↓
[4] Send question + context to LLM
    ↓
Answer with sources

```

Agents & Tool Calling
-------------------------

[](#agents--tool-calling)

### Creating an Agent

[](#creating-an-agent)

```
$agent = Neuro::agent('openai')
    ->session('user-123')
    ->maxSteps(5)
    ->tool('get_time', function () {
        return now()->toDateTimeString();
    }, 'Get the current date and time')
    ->tool('calculate', function (float $a, string $op, float $b) {
        return match ($op) { '+' => $a + $b, '-' => $a - $b, '*' => $a * $b, '/' => $a / $b };
    }, 'Perform a calculation');

$result = $agent->run('What time is it?');
// $result['response'] => string
// $result['steps'] => int
```

### Registering Tools via Manager

[](#registering-tools-via-manager)

```
use Manik\Neuro\Facades\Neuro;

$driver = Neuro::llm()->driver('openai');
$driver->tools($messages, [
    [
        'type' => 'function',
        'function' => [
            'name' => 'search_web',
            'description' => 'Search the web for information',
            'parameters' => [
                'type' => 'object',
                'required' => ['query'],
                'properties' => [
                    'query' => ['type' => 'string', 'description' => 'Search query'],
                ],
            ],
        ],
    ],
]);
```

Memory
------

[](#memory)

### Available Drivers

[](#available-drivers)

DriverKeyStorageDescriptionSession`session`Laravel sessionPer-request/session memoryConversation`conversation`In-memoryRuntime conversation historyPersistent`persistent`DatabaseLong-term persistent storage### Usage

[](#usage)

```
// Using the memory manager
Neuro::memory()->driver('session')->add('session-1', [
    'role' => 'user',
    'content' => 'Hello!',
]);

$history = Neuro::memory()->driver('session')->get('session-1');
// Returns array of messages, limited by config

Neuro::memory()->driver('session')->clear('session-1');
```

### Persistent Memory

[](#persistent-memory)

```
// Requires running the migration
Neuro::memory()->driver('persistent')->add('user-456', [
    'role' => 'user',
    'content' => 'Remember my name is John',
]);

$history = Neuro::memory()->driver('persistent')->get('user-456');
```

Image Generation
----------------

[](#image-generation)

### OpenAI DALL-E

[](#openai-dall-e)

```
$result = Neuro::image()
    ->driver('openai')
    ->generate('A serene mountain landscape at sunset', [
        'size' => '1024x1024',
        'quality' => 'hd',
    ]);

// $result['url'] => string
// $result['revised_prompt'] => string
```

### Edit Image

[](#edit-image)

```
$result = Neuro::image()
    ->driver('openai')
    ->edit('/path/to/image.png', 'Add a rainbow to the sky');
```

### Variations

[](#variations)

```
$result = Neuro::image()
    ->driver('openai')
    ->variations('/path/to/image.png', ['n' => 3]);
```

Speech Processing
-----------------

[](#speech-processing)

### Text-to-Speech

[](#text-to-speech)

```
$audioContent = Neuro::speech()
    ->driver('openai')
    ->synthesize('Hello, welcome to Laravel AI!', [
        'voice' => 'alloy',
        'model' => 'tts-1',
    ]);

// Save to file
Storage::put('audio/welcome.mp3', $audioContent);
```

### Speech-to-Text

[](#speech-to-text)

```
$transcription = Neuro::speech()
    ->driver('openai')
    ->transcribe('/path/to/audio.mp3');

// $transcription['text'] => string
```

Document Ingestion & Chunking
---------------------------------

[](#document-ingestion--chunking)

### Supported Formats

[](#supported-formats)

FormatAuto-detected`.txt`✅`.md`✅`.html`✅`.csv`✅`.json`✅### Ingest a Document

[](#ingest-a-document)

```
Neuro::rag()->ingestion()
    ->ingestFromPath(storage_path('docs/laravel-intro.md'), 'knowledge_base');
```

### Ingest Raw Content

[](#ingest-raw-content)

```
Neuro::rag()->ingestion()
    ->ingestRaw('# Laravel\nLaravel is a PHP framework...', 'knowledge_base', [
        'source' => 'manual',
        'author' => 'John',
    ]);
```

### Chunking Strategies

[](#chunking-strategies)

StrategyClassDescriptionFixed Size`FixedSizeChunking`Split by character count with overlapRecursive`RecursiveChunking`Split by paragraphs → sentences → charsSemantic`SemanticChunking`Split by headings and blank linesSliding Window`SlidingWindowChunking`Overlapping windows with stride```
use Manik\Neuro\RAG\Chunking\SemanticChunking;

Neuro::rag()->ingestion()
    ->setChunkStrategy(new SemanticChunking)
    ->ingestRaw($markdownContent, 'docs');
```

### Full Ingestion Pipeline

[](#full-ingestion-pipeline)

```
Document
    ↓ Chunking (FixedSize / Recursive / Semantic / SlidingWindow)
Chunks
    ↓ Embedding (via configured embedding provider)
Vector Embeddings
    ↓ Upsert to Vector Store
Stored in Collection

```

Testing
-------

[](#testing)

### Fake Responses

[](#fake-responses)

```
use Manik\Neuro\Facades\Neuro;

// Enable fake mode
Neuro::fake();

// All chat calls now return fake responses
$response = Neuro::chat()
    ->message('This will not hit the API')
    ->chat();

// $response['content'] === 'fake response'
```

### Fake Embeddings

[](#fake-embeddings)

```
Neuro::fake();

$result = Neuro::chat()
    ->text('Test text')
    ->embed('openai');

// Returns zeroed-out embedding vector with 1536 dimensions
```

Events & Observability
--------------------------

[](#events--observability)

### Events

[](#events)

EventDescriptionPayload`MessageSending`Before an LLM call is madeprovider, model, messages, options`MessageReceived`After an LLM responseprovider, model, response, latency`EmbeddingCreated`After embedding is generatedprovider, model, text, dimensions`VectorStored`After vectors are upsertedprovider, collection, record\_count`DocumentIndexed`After a document is indexedcollection, document, chunk\_count```
use Manik\Neuro\Events\MessageReceived;

Event::listen(MessageReceived::class, function (MessageReceived $event) {
    Log::info('LLM call completed', [
        'provider' => $event->provider,
        'model' => $event->model,
        'latency' => $event->latency,
    ]);
});
```

### Observability Configuration

[](#observability-configuration)

```
// config/neuro.php
'observability' => [
    'track_cost' => env('AI_TRACK_COST', false),
    'track_tokens' => env('AI_TRACK_TOKENS', false),
    'track_latency' => env('AI_TRACK_LATENCY', false),
    'store' => env('AI_OBSERVABILITY_STORE', 'log'),
],
```

Architecture
------------

[](#architecture)

```
┌─────────────────────────────────────────────────────────┐
│                    Facade (Neuro::)                      │
├─────────────────────────────────────────────────────────┤
│                    AIClient                             │
├─────────────────────────────────────────────────────────┤
│                   NeuroManager                         │
├──────┬──────┬──────┬──────┬──────┬──────┬──────┬───────┤
│  LLM │Embed │Vector│ Image│Speech│ RAG  │Memory│ Agent │
│Manager│Mgr   │Mgr   │ Mgr  │ Mgr  │ Mgr  │ Mgr  │       │
├──────┼──────┼──────┼──────┼──────┼──────┼──────┼───────┤
│Driver│Driver│Driver│Driver│Driver│Pipeline│Drivers│Agent│
│  AI  │  AI  │  DB  │  AI  │  AI  │+Chunk │Session│+Tools│
│Anthrop│Ollama│Qdrant│DALL-E│TTS   │+Ingest│Persist│      │
│Gemini│Mistral│Pinecn│      │STT   │+Rerank│       │      │
│Ollama│Cohere│pgvec │      │      │       │       │      │
│Others│      │Weav. │      │      │       │       │      │
└──────┴──────┴──────┴──────┴──────┴──────┴──────┴───────┘

```

### Extending with Custom Drivers

[](#extending-with-custom-drivers)

You can register custom drivers at runtime:

```
// Custom LLM driver
Neuro::llm()->extend('my-provider', function ($app) {
    return new MyCustomDriver(config('ai.llm.my-provider'));
});

// Custom embedding driver
Neuro::embedding()->extend('my-embedder', function ($app) {
    return new MyEmbedder(config('ai.embedding.my-embedder'));
});

// Custom vector driver
Neuro::vector()->extend('my-vector-db', function ($app) {
    return new MyVectorDB(config('ai.vector.my-vector-db'));
});
```

Then add the corresponding config to `config/neuro.php` and use it:

```
$response = Neuro::chat()
    ->provider('my-provider')
    ->message('Hello')
    ->chat();
```

---

License
-------

[](#license)

The MIT License (MIT). See [LICENSE](LICENSE) for more information.

###  Health Score

43

—

FairBetter than 89% of packages

Maintenance90

Actively maintained with recent releases

Popularity12

Limited adoption so far

Community7

Small or concentrated contributor base

Maturity52

Maturing project, gaining track record

 Bus Factor1

Top contributor holds 100% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Every ~0 days

Total

4

Last Release

50d ago

### Community

Maintainers

![](https://avatars.githubusercontent.com/u/12657913?v=4)[manikmia](/maintainers/manikmia)[@manikmia](https://github.com/manikmia)

---

Top Contributors

[![dev-manik-mia](https://avatars.githubusercontent.com/u/135939845?v=4)](https://github.com/dev-manik-mia "dev-manik-mia (6 commits)")

###  Code Quality

TestsPest

### Embed Badge

![Health badge](/badges/manik-neuro/health.svg)

```
[![Health](https://phpackages.com/badges/manik-neuro/health.svg)](https://phpackages.com/packages/manik-neuro)
```

###  Alternatives

[statamic/cms

The Statamic CMS Core Package

4.8k3.6M1.0k](/packages/statamic-cms)[backpack/crud

Quickly build admin interfaces using Laravel, Bootstrap and JavaScript.

3.4k3.7M223](/packages/backpack-crud)[leantime/leantime

Open source project management system for non-project managers. Simple like Trello, powerful like Jira. Built with neurodiversity in mind.

10.2k4.0k](/packages/leantime-leantime)[unopim/unopim

UnoPim Laravel PIM

10.5k2.4k](/packages/unopim-unopim)[tencentcloud/tencentcloud-sdk-php

TencentCloudApi php sdk

3661.3M47](/packages/tencentcloud-tencentcloud-sdk-php)[eslazarev/wildberries-sdk

Wildberries OpenAPI clients (generated).

293.1k](/packages/eslazarev-wildberries-sdk)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)