2import { NextResponse } from 'next/server'

3export async function POST(req: Request) {

4 const { email } = await req.json()

5 return NextResponse.json({ ok: true })

8const useStack = <T,>(): Stack<T> => {

9 const [items, setItems] = useState<T[]>([])

10 const push = (item: T) => setItems(p => [...p, item])

11 return { items, push }

12}

14class FacturaElectronica(models.Model):

15 cufe = models.CharField(max_length=96, unique=True)

16 prefijo = models.CharField(max_length=4)

17 consecutivo = models.PositiveIntegerField()

18 total = models.DecimalField(max_digits=18, decimal_places=2)

20SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

21FROM usuarios u

22LEFT JOIN pedidos p ON p.usuario_id = u.id

23WHERE u.activo = true GROUP BY u.id;

25{

26 "servicio": "halu-medic",

27 "version": "2.4.1",

28 "runtime": "python3.12",

29 "region": "us-east-1"

30}

32const App: FC = () => (

33 <Layout>

34 <Hero />

35 <Services />

36 </Layout>

37)

39@app.route('/api/facturas', methods=['POST'])

40def crear_factura():

41 data = request.get_json()

42 return jsonify(servicio.crear(data))

44interface Cliente {

45 id: string

46 nombre: string

47 nit: string

48 activo: boolean

49}

51docker compose up -d --build

52nginx -s reload

53pytest tests/ -v --cov=app

54npm run build && npm run start

56await celery.send_task('rips.procesar', args=[batch_id])

57cache.set(key, value, timeout=3600)

59import { NextResponse } from 'next/server'

60export async function POST(req: Request) {

61 const { email } = await req.json()

62 return NextResponse.json({ ok: true })

63}

65const useStack = <T,>(): Stack<T> => {

66 const [items, setItems] = useState<T[]>([])

67 const push = (item: T) => setItems(p => [...p, item])

68 return { items, push }

69}

71class FacturaElectronica(models.Model):

72 cufe = models.CharField(max_length=96, unique=True)

73 prefijo = models.CharField(max_length=4)

74 consecutivo = models.PositiveIntegerField()

75 total = models.DecimalField(max_digits=18, decimal_places=2)

77SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

78FROM usuarios u

79LEFT JOIN pedidos p ON p.usuario_id = u.id

80WHERE u.activo = true GROUP BY u.id;

82{

83 "servicio": "halu-medic",

84 "version": "2.4.1",

85 "runtime": "python3.12",

86 "region": "us-east-1"

87}

89const App: FC = () => (

90 <Layout>

91 <Hero />

92 <Services />

93 </Layout>

94)

96@app.route('/api/facturas', methods=['POST'])

97def crear_factura():

98 data = request.get_json()

99 return jsonify(servicio.crear(data))

100

101interface Cliente {

102 id: string

103 nombre: string

104 nit: string

105 activo: boolean

106}

107

108docker compose up -d --build

109nginx -s reload

110pytest tests/ -v --cov=app

111npm run build && npm run start

112

113await celery.send_task('rips.procesar', args=[batch_id])

114cache.set(key, value, timeout=3600)

115

43import { NextResponse } from 'next/server'

44export async function POST(req: Request) {

45 const { email } = await req.json()

46 return NextResponse.json({ ok: true })

47}

49const useStack = <T,>(): Stack<T> => {

50 const [items, setItems] = useState<T[]>([])

51 const push = (item: T) => setItems(p => [...p, item])

52 return { items, push }

53}

55class FacturaElectronica(models.Model):

56 cufe = models.CharField(max_length=96, unique=True)

57 prefijo = models.CharField(max_length=4)

58 consecutivo = models.PositiveIntegerField()

59 total = models.DecimalField(max_digits=18, decimal_places=2)

61SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

62FROM usuarios u

63LEFT JOIN pedidos p ON p.usuario_id = u.id

64WHERE u.activo = true GROUP BY u.id;

66{

67 "servicio": "halu-medic",

68 "version": "2.4.1",

69 "runtime": "python3.12",

70 "region": "us-east-1"

71}

73const App: FC = () => (

74 <Layout>

75 <Hero />

76 <Services />

77 </Layout>

78)

80@app.route('/api/facturas', methods=['POST'])

81def crear_factura():

82 data = request.get_json()

83 return jsonify(servicio.crear(data))

85interface Cliente {

86 id: string

87 nombre: string

88 nit: string

89 activo: boolean

90}

92docker compose up -d --build

93nginx -s reload

94pytest tests/ -v --cov=app

95npm run build && npm run start

97await celery.send_task('rips.procesar', args=[batch_id])

98cache.set(key, value, timeout=3600)

100import { NextResponse } from 'next/server'

101export async function POST(req: Request) {

102 const { email } = await req.json()

103 return NextResponse.json({ ok: true })

104}

105

106const useStack = <T,>(): Stack<T> => {

107 const [items, setItems] = useState<T[]>([])

108 const push = (item: T) => setItems(p => [...p, item])

109 return { items, push }

110}

111

112class FacturaElectronica(models.Model):

113 cufe = models.CharField(max_length=96, unique=True)

114 prefijo = models.CharField(max_length=4)

115 consecutivo = models.PositiveIntegerField()

116 total = models.DecimalField(max_digits=18, decimal_places=2)

117

118SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

119FROM usuarios u

120LEFT JOIN pedidos p ON p.usuario_id = u.id

121WHERE u.activo = true GROUP BY u.id;

122

123{

124 "servicio": "halu-medic",

125 "version": "2.4.1",

126 "runtime": "python3.12",

127 "region": "us-east-1"

128}

129

130const App: FC = () => (

131 <Layout>

132 <Hero />

133 <Services />

134 </Layout>

135)

136

137@app.route('/api/facturas', methods=['POST'])

138def crear_factura():

139 data = request.get_json()

140 return jsonify(servicio.crear(data))

141

142interface Cliente {

143 id: string

144 nombre: string

145 nit: string

146 activo: boolean

147}

148

149docker compose up -d --build

150nginx -s reload

151pytest tests/ -v --cov=app

152npm run build && npm run start

153

154await celery.send_task('rips.procesar', args=[batch_id])

155cache.set(key, value, timeout=3600)

156

85import { NextResponse } from 'next/server'

86export async function POST(req: Request) {

87 const { email } = await req.json()

88 return NextResponse.json({ ok: true })

89}

91const useStack = <T,>(): Stack<T> => {

92 const [items, setItems] = useState<T[]>([])

93 const push = (item: T) => setItems(p => [...p, item])

94 return { items, push }

95}

97class FacturaElectronica(models.Model):

98 cufe = models.CharField(max_length=96, unique=True)

99 prefijo = models.CharField(max_length=4)

100 consecutivo = models.PositiveIntegerField()

101 total = models.DecimalField(max_digits=18, decimal_places=2)

102

103SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

104FROM usuarios u

105LEFT JOIN pedidos p ON p.usuario_id = u.id

106WHERE u.activo = true GROUP BY u.id;

107

108{

109 "servicio": "halu-medic",

110 "version": "2.4.1",

111 "runtime": "python3.12",

112 "region": "us-east-1"

113}

114

115const App: FC = () => (

116 <Layout>

117 <Hero />

118 <Services />

119 </Layout>

120)

121

122@app.route('/api/facturas', methods=['POST'])

123def crear_factura():

124 data = request.get_json()

125 return jsonify(servicio.crear(data))

126

127interface Cliente {

128 id: string

129 nombre: string

130 nit: string

131 activo: boolean

132}

133

134docker compose up -d --build

135nginx -s reload

136pytest tests/ -v --cov=app

137npm run build && npm run start

138

139await celery.send_task('rips.procesar', args=[batch_id])

140cache.set(key, value, timeout=3600)

141

142import { NextResponse } from 'next/server'

143export async function POST(req: Request) {

144 const { email } = await req.json()

145 return NextResponse.json({ ok: true })

146}

147

148const useStack = <T,>(): Stack<T> => {

149 const [items, setItems] = useState<T[]>([])

150 const push = (item: T) => setItems(p => [...p, item])

151 return { items, push }

152}

153

154class FacturaElectronica(models.Model):

155 cufe = models.CharField(max_length=96, unique=True)

156 prefijo = models.CharField(max_length=4)

157 consecutivo = models.PositiveIntegerField()

158 total = models.DecimalField(max_digits=18, decimal_places=2)

159

160SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

161FROM usuarios u

162LEFT JOIN pedidos p ON p.usuario_id = u.id

163WHERE u.activo = true GROUP BY u.id;

164

165{

166 "servicio": "halu-medic",

167 "version": "2.4.1",

168 "runtime": "python3.12",

169 "region": "us-east-1"

170}

171

172const App: FC = () => (

173 <Layout>

174 <Hero />

175 <Services />

176 </Layout>

177)

178

179@app.route('/api/facturas', methods=['POST'])

180def crear_factura():

181 data = request.get_json()

182 return jsonify(servicio.crear(data))

183

184interface Cliente {

185 id: string

186 nombre: string

187 nit: string

188 activo: boolean

189}

190

191docker compose up -d --build

192nginx -s reload

193pytest tests/ -v --cov=app

194npm run build && npm run start

195

196await celery.send_task('rips.procesar', args=[batch_id])

197cache.set(key, value, timeout=3600)

198

127import { NextResponse } from 'next/server'

128export async function POST(req: Request) {

129 const { email } = await req.json()

130 return NextResponse.json({ ok: true })

131}

132

133const useStack = <T,>(): Stack<T> => {

134 const [items, setItems] = useState<T[]>([])

135 const push = (item: T) => setItems(p => [...p, item])

136 return { items, push }

137}

138

139class FacturaElectronica(models.Model):

140 cufe = models.CharField(max_length=96, unique=True)

141 prefijo = models.CharField(max_length=4)

142 consecutivo = models.PositiveIntegerField()

143 total = models.DecimalField(max_digits=18, decimal_places=2)

144

145SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

146FROM usuarios u

147LEFT JOIN pedidos p ON p.usuario_id = u.id

148WHERE u.activo = true GROUP BY u.id;

149

150{

151 "servicio": "halu-medic",

152 "version": "2.4.1",

153 "runtime": "python3.12",

154 "region": "us-east-1"

155}

156

157const App: FC = () => (

158 <Layout>

159 <Hero />

160 <Services />

161 </Layout>

162)

163

164@app.route('/api/facturas', methods=['POST'])

165def crear_factura():

166 data = request.get_json()

167 return jsonify(servicio.crear(data))

168

169interface Cliente {

170 id: string

171 nombre: string

172 nit: string

173 activo: boolean

174}

175

176docker compose up -d --build

177nginx -s reload

178pytest tests/ -v --cov=app

179npm run build && npm run start

180

181await celery.send_task('rips.procesar', args=[batch_id])

182cache.set(key, value, timeout=3600)

183

184import { NextResponse } from 'next/server'

185export async function POST(req: Request) {

186 const { email } = await req.json()

187 return NextResponse.json({ ok: true })

188}

189

190const useStack = <T,>(): Stack<T> => {

191 const [items, setItems] = useState<T[]>([])

192 const push = (item: T) => setItems(p => [...p, item])

193 return { items, push }

194}

195

196class FacturaElectronica(models.Model):

197 cufe = models.CharField(max_length=96, unique=True)

198 prefijo = models.CharField(max_length=4)

199 consecutivo = models.PositiveIntegerField()

200 total = models.DecimalField(max_digits=18, decimal_places=2)

201

202SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

203FROM usuarios u

204LEFT JOIN pedidos p ON p.usuario_id = u.id

205WHERE u.activo = true GROUP BY u.id;

206

207{

208 "servicio": "halu-medic",

209 "version": "2.4.1",

210 "runtime": "python3.12",

211 "region": "us-east-1"

212}

213

214const App: FC = () => (

215 <Layout>

216 <Hero />

217 <Services />

218 </Layout>

219)

220

221@app.route('/api/facturas', methods=['POST'])

222def crear_factura():

223 data = request.get_json()

224 return jsonify(servicio.crear(data))

225

226interface Cliente {

227 id: string

228 nombre: string

229 nit: string

230 activo: boolean

231}

232

233docker compose up -d --build

234nginx -s reload

235pytest tests/ -v --cov=app

236npm run build && npm run start

237

238await celery.send_task('rips.procesar', args=[batch_id])

239cache.set(key, value, timeout=3600)

240

169import { NextResponse } from 'next/server'

170export async function POST(req: Request) {

171 const { email } = await req.json()

172 return NextResponse.json({ ok: true })

173}

174

175const useStack = <T,>(): Stack<T> => {

176 const [items, setItems] = useState<T[]>([])

177 const push = (item: T) => setItems(p => [...p, item])

178 return { items, push }

179}

180

181class FacturaElectronica(models.Model):

182 cufe = models.CharField(max_length=96, unique=True)

183 prefijo = models.CharField(max_length=4)

184 consecutivo = models.PositiveIntegerField()

185 total = models.DecimalField(max_digits=18, decimal_places=2)

186

187SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

188FROM usuarios u

189LEFT JOIN pedidos p ON p.usuario_id = u.id

190WHERE u.activo = true GROUP BY u.id;

191

192{

193 "servicio": "halu-medic",

194 "version": "2.4.1",

195 "runtime": "python3.12",

196 "region": "us-east-1"

197}

198

199const App: FC = () => (

200 <Layout>

201 <Hero />

202 <Services />

203 </Layout>

204)

205

206@app.route('/api/facturas', methods=['POST'])

207def crear_factura():

208 data = request.get_json()

209 return jsonify(servicio.crear(data))

210

211interface Cliente {

212 id: string

213 nombre: string

214 nit: string

215 activo: boolean

216}

217

218docker compose up -d --build

219nginx -s reload

220pytest tests/ -v --cov=app

221npm run build && npm run start

222

223await celery.send_task('rips.procesar', args=[batch_id])

224cache.set(key, value, timeout=3600)

225

226import { NextResponse } from 'next/server'

227export async function POST(req: Request) {

228 const { email } = await req.json()

229 return NextResponse.json({ ok: true })

230}

231

232const useStack = <T,>(): Stack<T> => {

233 const [items, setItems] = useState<T[]>([])

234 const push = (item: T) => setItems(p => [...p, item])

235 return { items, push }

236}

237

238class FacturaElectronica(models.Model):

239 cufe = models.CharField(max_length=96, unique=True)

240 prefijo = models.CharField(max_length=4)

241 consecutivo = models.PositiveIntegerField()

242 total = models.DecimalField(max_digits=18, decimal_places=2)

243

244SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

245FROM usuarios u

246LEFT JOIN pedidos p ON p.usuario_id = u.id

247WHERE u.activo = true GROUP BY u.id;

248

249{

250 "servicio": "halu-medic",

251 "version": "2.4.1",

252 "runtime": "python3.12",

253 "region": "us-east-1"

254}

255

256const App: FC = () => (

257 <Layout>

258 <Hero />

259 <Services />

260 </Layout>

261)

262

263@app.route('/api/facturas', methods=['POST'])

264def crear_factura():

265 data = request.get_json()

266 return jsonify(servicio.crear(data))

267

268interface Cliente {

269 id: string

270 nombre: string

271 nit: string

272 activo: boolean

273}

274

275docker compose up -d --build

276nginx -s reload

277pytest tests/ -v --cov=app

278npm run build && npm run start

279

280await celery.send_task('rips.procesar', args=[batch_id])

281cache.set(key, value, timeout=3600)

282

211import { NextResponse } from 'next/server'

212export async function POST(req: Request) {

213 const { email } = await req.json()

214 return NextResponse.json({ ok: true })

215}

216

217const useStack = <T,>(): Stack<T> => {

218 const [items, setItems] = useState<T[]>([])

219 const push = (item: T) => setItems(p => [...p, item])

220 return { items, push }

221}

222

223class FacturaElectronica(models.Model):

224 cufe = models.CharField(max_length=96, unique=True)

225 prefijo = models.CharField(max_length=4)

226 consecutivo = models.PositiveIntegerField()

227 total = models.DecimalField(max_digits=18, decimal_places=2)

228

229SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

230FROM usuarios u

231LEFT JOIN pedidos p ON p.usuario_id = u.id

232WHERE u.activo = true GROUP BY u.id;

233

234{

235 "servicio": "halu-medic",

236 "version": "2.4.1",

237 "runtime": "python3.12",

238 "region": "us-east-1"

239}

240

241const App: FC = () => (

242 <Layout>

243 <Hero />

244 <Services />

245 </Layout>

246)

247

248@app.route('/api/facturas', methods=['POST'])

249def crear_factura():

250 data = request.get_json()

251 return jsonify(servicio.crear(data))

252

253interface Cliente {

254 id: string

255 nombre: string

256 nit: string

257 activo: boolean

258}

259

260docker compose up -d --build

261nginx -s reload

262pytest tests/ -v --cov=app

263npm run build && npm run start

264

265await celery.send_task('rips.procesar', args=[batch_id])

266cache.set(key, value, timeout=3600)

267

268import { NextResponse } from 'next/server'

269export async function POST(req: Request) {

270 const { email } = await req.json()

271 return NextResponse.json({ ok: true })

272}

273

274const useStack = <T,>(): Stack<T> => {

275 const [items, setItems] = useState<T[]>([])

276 const push = (item: T) => setItems(p => [...p, item])

277 return { items, push }

278}

279

280class FacturaElectronica(models.Model):

281 cufe = models.CharField(max_length=96, unique=True)

282 prefijo = models.CharField(max_length=4)

283 consecutivo = models.PositiveIntegerField()

284 total = models.DecimalField(max_digits=18, decimal_places=2)

285

286SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

287FROM usuarios u

288LEFT JOIN pedidos p ON p.usuario_id = u.id

289WHERE u.activo = true GROUP BY u.id;

290

291{

292 "servicio": "halu-medic",

293 "version": "2.4.1",

294 "runtime": "python3.12",

295 "region": "us-east-1"

296}

297

298const App: FC = () => (

299 <Layout>

300 <Hero />

301 <Services />

302 </Layout>

303)

304

305@app.route('/api/facturas', methods=['POST'])

306def crear_factura():

307 data = request.get_json()

308 return jsonify(servicio.crear(data))

309

310interface Cliente {

311 id: string

312 nombre: string

313 nit: string

314 activo: boolean

315}

316

317docker compose up -d --build

318nginx -s reload

319pytest tests/ -v --cov=app

320npm run build && npm run start

321

322await celery.send_task('rips.procesar', args=[batch_id])

323cache.set(key, value, timeout=3600)

324

AXENTIATECHNOLOGIES

$Hablemos

v2026.06 · Sabanalarga · Barranquilla

Construimos el software que su empresa necesita para crecer.

Desarrollo a medida con tecnología de nivel empresarial. Desde una landing hasta plataformas SaaS completas.

Ver lo que hacemos Contáctanos

Productos SaaS

100%

A medida

24/7

Soporte

~/axentia — zsh — 80×24

axentia@dev:~$ ▍

// services.tsx

Soporte continuo, métricas claras y posicionamiento sostenido en buscadores.

SLAMonitoringSEO

}

// editor — open project

Stack tecnológico

Las herramientas reales con las que construimos.

No improvisamos. Usamos tecnologías probadas que escalan con su negocio y permiten mantener el código durante años.

axentia / stack

// Capa de presentación · UI rápida y reactiva

export const frontend = {

framework: "Next.js 14",

library: "React 18",

language: "TypeScript",

styling: "Tailwind CSS",

motion: "Framer Motion",

icons: "lucide-react",

Soluciones de inteligencia artificial aplicadas a salud y educación: asistentes y analítica.

uptime

—

tenants

beta

stack

DJ/PG

// next.product

¿Su próximo producto?

Construyamos juntos la siguiente plataforma de su industria.

Empecemos

// build-pipeline.log

Cómo trabajamos

Un pipeline claro, desde la idea hasta producción.

Cada proyecto sigue un pipeline reproducible. Sabe en todo momento qué está pasando con su software.

$ ./axentia-pipeline.sh

● running

[01]✓

axentia@dev$discovery --cliente02:14

Entendemos su proceso, objetivos y restricciones reales.

[02]✓

axentia@dev$design --arquitectura03:48

Definimos stack, base de datos y arquitectura escalable.

[03]✓

axentia@dev$build --sprint=2w14:00

Construimos por iteraciones con entregas demostrables.

[04]✓

axentia@dev$test --coverage04:32

Pruebas automatizadas, revisión de seguridad y rendimiento.

[05]✓

axentia@dev$deploy --production01:22

Despliegue continuo en infraestructura preparada para escalar.

[06]✓

axentia@dev$support --24x7∞

Monitoreo, métricas y soporte continuo posterior al lanzamiento.

✓ build successful — deployed to production▍

$ ./hablemos.sh

¿Listo para construir? Compilemos su proyecto.

Cuéntenos qué necesita construir. Le respondemos rápido con una propuesta clara, tiempos honestos y un alcance bien definido.

WhatsApp · +57 324 686 8538 Enviar correo

contact.json

contacto@axentiatechnologies.com

+57 324 686 8538

ubicación

Sabanalarga y Barranquilla

Atlántico, Colombia

respuesta

< 24 horas hábiles